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

0026961: Recover possibility to read files in old persistence format -- preparation

Browse Source 
Added basic support for possibility to read filed in old persistent format.
Toolkits TKStd, TKStdL, TKShape added to provide necessary tools (to be done).
Obsolete interfaces are removed from classes in PCDM and Storage.
This commit is contained in:
myn 2015-12-09 20:27:36 +03:00 committed by abv
parent ede9746c21
commit 7ed7467da3
79 changed files with 2010 additions and 1287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
adm/MODULES
View File

@ -2,6 +2,6 @@ FoundationClasses TKernel TKMath
ModelingData TKG2d TKG3d TKGeomBase TKBRep
ModelingAlgorithms TKGeomAlgo TKTopAlgo TKPrim TKBO TKBool TKHLR TKFillet TKOffset TKFeat TKMesh TKXMesh TKShHealing
Visualization TKService TKV3d TKOpenGl TKMeshVS TKIVtk TKD3DHost
ApplicationFramework TKCDF TKLCAF TKCAF TKBinL TKXmlL TKBin TKXml FWOSPlugin TKTObj TKBinTObj TKXmlTObj TKVCAF
ApplicationFramework TKCDF TKLCAF TKCAF TKBinL TKXmlL TKBin TKXml TKStdL TKStd TKShape FWOSPlugin TKTObj TKBinTObj TKXmlTObj TKVCAF
DataExchange TKXSBase TKSTEPBase TKSTEPAttr TKSTEP209 TKSTEP TKIGES TKXCAF TKXDEIGES TKXDESTEP TKSTL TKVRML TKXmlXCAF TKBinXCAF
Draw TKDraw TKTopTest TKViewerTest TKXSDRAW TKDCAF TKXDEDRAW TKTObjDRAW TKQADraw TKIVtkDraw DRAWEXE

9
adm/UDLIST
View File

@ -243,6 +243,12 @@ n CDF
n CDM
n FWOSDriver
n PCDM
n StdLDrivers
n StdLPersistent
n StdObjMgt
n StdDrivers
n StdPersistent
n ShapePersistent
n TDF
n TDataStd
n TDataXtd
@ -271,6 +277,9 @@ t TKCAF
t TKCDF
t TKLCAF
t TKStdL
t TKStd
t TKShape
t TKTObj
t TKXml
t TKXmlL

21
src/BinLDrivers/BinLDrivers_DocumentRetrievalDriver.cxx
View File

@ -70,27 +70,6 @@ Handle(CDM_Document) BinLDrivers_DocumentRetrievalDriver::CreateDocument()
return new TDocStd_Document(PCDM_RetrievalDriver::GetFormat());
}
//=======================================================================
//function : SchemaName
//purpose : pure virtual method definition
//=======================================================================
TCollection_ExtendedString BinLDrivers_DocumentRetrievalDriver::SchemaName() const
{
TCollection_ExtendedString schemaname;
return schemaname;
}
//=======================================================================
//function : Make
//purpose : pure virtual method definition
//=======================================================================
void BinLDrivers_DocumentRetrievalDriver::Make (const Handle(PCDM_Document)&,
const Handle(CDM_Document)&)
{
}
//=======================================================================
//function : Read
//purpose :

6
src/BinLDrivers/BinLDrivers_DocumentRetrievalDriver.hxx
View File

@ -55,12 +55,6 @@ public:
//! Constructor
Standard_EXPORT BinLDrivers_DocumentRetrievalDriver();
//! pure virtual method definition
Standard_EXPORT virtual TCollection_ExtendedString SchemaName() const Standard_OVERRIDE;
//! pure virtual method definition
Standard_EXPORT virtual void Make (const Handle(PCDM_Document)& PD, const Handle(CDM_Document)& TD) Standard_OVERRIDE;
//! pure virtual method definition
Standard_EXPORT virtual Handle(CDM_Document) CreateDocument() Standard_OVERRIDE;

17
src/OS/ApplicationFramework.tcl
View File

@ -16,15 +16,18 @@
;#
proc ApplicationFramework:toolkits { } {
return [list \
TKCDF \
TKLCAF \
TKVCAF \
TKCDF \
TKLCAF \
TKVCAF \
TKCAF \
TKBinL \
TKXmlL \
TKBin \
TKXml \
FWOSPlugin \
FWOSPlugin \
TKStdL \
TKStd \
TKShape \
TKTObj \
TKBinTObj \
TKXmlTObj \
@ -34,10 +37,10 @@ proc ApplicationFramework:toolkits { } {
;# Autres UDs a prendre.
;#
proc ApplicationFramework:ressources { } {
return [list \
[list both r StdResource {}] \
return [list \
[list both r StdResource {}] \
[list both r XmlOcafResource {}] \
]
]
}
;#
;# Nom du module

20
src/PCDM/PCDM.cxx
View File

@ -60,26 +60,6 @@ Standard_Boolean PCDM::FindStorageDriver(const Handle(CDM_Document)& aDocument)
return aDocument->FindStoragePlugin();
}
//=======================================================================
//function : Schema
//purpose : returns a schema to be used during a Store or Retrieve
// operation.
// Schema will plug the schema defined by
// the SchemaName method.
//=======================================================================
Handle(Storage_Schema) PCDM::Schema(const TCollection_ExtendedString& aSchemaName, const Handle(CDM_Application)& anApplication) {
Handle(Resource_Manager) r = anApplication->Resources();
if(!UTL::Find(r,aSchemaName)) {
Standard_SStream aMsg; aMsg << "could not find the plugin resource for the schema: " << TCollection_ExtendedString(aSchemaName) << (char)0;
Standard_NoSuchObject::Raise(aMsg);
}
Handle(Standard_Transient) t = Plugin::Load(UTL::GUID(UTL::Value(r,aSchemaName)));
return Handle(Storage_Schema)::DownCast (t);
}
//=======================================================================
//function : FileDriverType
//purpose :

54
src/PCDM/PCDM.hxx
View File

@ -28,75 +28,23 @@
#include <PCDM_BaseDriverPointer.hxx>
class CDM_Document;
class PCDM_StorageDriver;
class Storage_Schema;
class TCollection_ExtendedString;
class CDM_Application;
class TCollection_AsciiString;
class PCDM_Document;
class PCDM_Reader;
class PCDM_Writer;
class PCDM_RetrievalDriver;
class PCDM_StorageDriver;
class PCDM_ReferenceIterator;
class PCDM_Reference;
class PCDM_ReadWriter;
class PCDM_ReadWriter_1;
class PCDM
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT static Standard_Boolean FindStorageDriver (const Handle(CDM_Document)& aDocument);
//! gets in the EuclidDesktop resource the plugin
//! identifier of the driver plugs the driver.
Standard_EXPORT static Handle(PCDM_StorageDriver) StorageDriver (const Handle(CDM_Document)& aDocument);
//! returns a schema to be used during a Store or Retrieve
//! operation.
//! Schema will plug the schema defined by
//! the SchemaName method.
Standard_EXPORT static Handle(Storage_Schema) Schema (const TCollection_ExtendedString& aSchemaName, const Handle(CDM_Application)& anApplication);
protected:
private:
Standard_EXPORT static PCDM_TypeOfFileDriver FileDriverType (const TCollection_AsciiString& aFileName, PCDM_BaseDriverPointer& aBaseDriver);
Standard_EXPORT static PCDM_TypeOfFileDriver FileDriverType (Standard_IStream& theIStream, PCDM_BaseDriverPointer& theBaseDriver);
friend class PCDM_Document;
friend class PCDM_Reader;
friend class PCDM_Writer;
friend class PCDM_RetrievalDriver;
friend class PCDM_StorageDriver;
friend class PCDM_ReferenceIterator;
friend class PCDM_Reference;
friend class PCDM_ReadWriter;
friend class PCDM_ReadWriter_1;
DEFINE_STANDARD_ALLOC
};
#endif // _PCDM_HeaderFile

14
src/PCDM/PCDM_ReadWriter.cxx
View File

@ -26,7 +26,6 @@
#include <Storage_BaseDriver.hxx>
#include <Storage_Data.hxx>
#include <Storage_HeaderData.hxx>
#include <Storage_Schema.hxx>
#include <Storage_TypeData.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
@ -130,9 +129,9 @@ TCollection_ExtendedString PCDM_ReadWriter::FileFormat
Open(*theFileDriver,aFileName,Storage_VSRead);
theFileIsOpen=Standard_True;
Handle(Storage_Schema) s = new Storage_Schema;
Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
Storage_HeaderData hd;
hd.Read (*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd.UserInfo();
Standard_Boolean found=Standard_False;
for (Standard_Integer i =1; !found && i<= refUserInfo.Length() ; i++) {
if(refUserInfo(i).Search(FILE_FORMAT) != -1) {
@ -141,7 +140,12 @@ TCollection_ExtendedString PCDM_ReadWriter::FileFormat
Standard_True);
}
}
if(!found) theFormat=s->ReadTypeSection(*theFileDriver)->Types()->Value(1);
if (!found)
{
Storage_TypeData td;
td.Read (*theFileDriver);
theFormat = td.Types()->Value(1);
}
}
catch (Standard_Failure) {}

15
src/PCDM/PCDM_ReadWriter_1.cxx
View File

@ -244,8 +244,9 @@ Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_Exten
theFileIsOpen=Standard_True;
Handle(Storage_Schema) s = new Storage_Schema;
Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
Storage_HeaderData hd;
hd.Read (*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd.UserInfo();
for ( i =1; i<= refUserInfo.Length() ; i++) {
if(refUserInfo(i).Search(REFERENCE_COUNTER) != -1) {
@ -347,8 +348,9 @@ void PCDM_ReadWriter_1::ReadUserInfo(const TCollection_ExtendedString& aFileName
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
Handle(Storage_Schema) s = new Storage_Schema;
Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
Storage_HeaderData hd;
hd.Read (*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd.UserInfo();
Standard_Integer debut=0,fin=0;
@ -390,8 +392,9 @@ Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_Extend
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
theFileIsOpen=Standard_True;
Handle(Storage_Schema) s = new Storage_Schema;
Handle(Storage_HeaderData) hd = s->ReadHeaderSection(*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd->UserInfo();
Storage_HeaderData hd;
hd.Read (*theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd.UserInfo();
static Standard_Integer i ;
for ( i =1; i<= refUserInfo.Length() ; i++) {

212
src/PCDM/PCDM_RetrievalDriver.cxx
View File

@ -31,44 +31,12 @@
#include <Standard_NoSuchObject.hxx>
#include <Standard_Type.hxx>
#include <Standard_TypeMismatch.hxx>
#include <Storage_Data.hxx>
#include <Storage_HeaderData.hxx>
#include <Storage_HSeqOfRoot.hxx>
#include <Storage_Root.hxx>
#include <Storage_Schema.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <locale.h>
IMPLEMENT_STANDARD_RTTIEXT(PCDM_RetrievalDriver,PCDM_Reader)
void PCDM_RetrievalDriver::RaiseIfUnknownTypes(const Handle(Storage_Schema)& aSchema, const TCollection_ExtendedString& aFileName) {
PCDM_BaseDriverPointer theFileDriver;
TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
return;
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
TColStd_SequenceOfAsciiString theUnknownTypes;
Standard_Boolean unknowns = aSchema->HasUnknownType(*theFileDriver,theUnknownTypes);
theFileDriver->Close();
delete theFileDriver;
if(unknowns) {
Standard_SStream aMsg; aMsg << "cannot read: `" << aFileName << "', because the following types: ";
for (Standard_Integer i=1; i <= theUnknownTypes.Length(); i++) {
aMsg << theUnknownTypes(i);
if(i< theUnknownTypes.Length()) aMsg <<",";
}
aMsg << " have been found in it but not in the available Schema: " << aSchema->Name() << (char)0;
Standard_TypeMismatch::Raise(aMsg);
}
}
//=======================================================================
//function : Read
//purpose :
@ -81,181 +49,17 @@ void PCDM_RetrievalDriver::Read(Standard_IStream& /*theIStream*/,
}
//=======================================================================
//function : Read
//purpose :
//=======================================================================
void PCDM_RetrievalDriver::References(const TCollection_ExtendedString& aFileName, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver)
{ PCDM_ReadWriter::Reader(aFileName)->ReadReferences(aFileName, theReferences, theMsgDriver);}
void PCDM_RetrievalDriver::Read(const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& aNewDocument,
const Handle(CDM_Application)& theApplication)
{
Standard_SStream aMsg;
Standard_Boolean Failure=Standard_False;
Handle(Storage_Schema) aSchema;
TColStd_SequenceOfExtendedString theExtensions;
myReaderStatus = PCDM_RS_OK;
{
try {
OCC_CATCH_SIGNALS
aSchema=PCDM::Schema(SchemaName(),theApplication);
Extensions(theFileName, theExtensions, theApplication->MessageDriver());
LoadExtensions(aSchema,theExtensions, theApplication->MessageDriver());
}
catch (Standard_NoSuchObject) {
aMsg << Standard_NoSuchObject::Caught() << endl;
myReaderStatus = PCDM_RS_NoSchema;
Failure=Standard_True;
}
catch (Standard_Failure) {
aMsg << Standard_Failure::Caught() << endl;
myReaderStatus = PCDM_RS_ExtensionFailure;
Failure=Standard_True;
}
if(Failure) Standard_Failure::Raise(aMsg);
}
Standard_Integer PCDM_RetrievalDriver::DocumentVersion(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver)
{ return PCDM_ReadWriter::Reader(aFileName)->ReadDocumentVersion(aFileName, theMsgDriver); }
PCDM_BaseDriverPointer theFileDriver;
TCollection_AsciiString aFileNameU(theFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown) {
myReaderStatus = PCDM_RS_UnknownFileDriver;
return;
}
{
try {
OCC_CATCH_SIGNALS
RaiseIfUnknownTypes(aSchema, theFileName);
PCDM_ReadWriter::Open(*theFileDriver,theFileName,Storage_VSRead);
}
catch (Standard_TypeMismatch) {
aMsg << Standard_TypeMismatch::Caught() << endl;
myReaderStatus = PCDM_RS_TypeNotFoundInSchema;
Failure=Standard_True;
}
catch (Standard_Failure) {
aMsg << Standard_Failure::Caught() << endl;
myReaderStatus = PCDM_RS_OpenError;
Failure=Standard_True;
}
if(Failure) Standard_Failure::Raise(aMsg);
}
Handle(Storage_Data) theData = aSchema->Read(*theFileDriver);
Storage_Error aStatus = theData->ErrorStatus();
if(aStatus != Storage_VSOk) {
switch (aStatus) {
case Storage_VSOpenError:
case Storage_VSNotOpen:
case Storage_VSAlreadyOpen:
myReaderStatus = PCDM_RS_OpenError;
aMsg << "Stream Open Error" << endl;
break;
case Storage_VSModeError:
myReaderStatus = PCDM_RS_WrongStreamMode;
aMsg << "Stream is opened with a wrong mode for operation" << endl;
break;
case Storage_VSSectionNotFound:
aMsg << "Section is not found" << endl;
myReaderStatus = PCDM_RS_FormatFailure;
break;
case Storage_VSFormatError:
myReaderStatus = PCDM_RS_FormatFailure;
aMsg << "Wrong format error" << endl;
break;
case Storage_VSUnknownType:
myReaderStatus = PCDM_RS_TypeFailure;
aMsg << "Try to read an unknown type" << endl;
break;
case Storage_VSTypeMismatch:
myReaderStatus = PCDM_RS_TypeFailure;
aMsg << "Try to read a wrong primitive type" << endl;
break;
default:
myReaderStatus = PCDM_RS_DriverFailure;
aMsg << "Retrieval Driver Failure" << endl;
}
Standard_Failure::Raise(aMsg);
}
theFileDriver->Close();
delete theFileDriver;
Handle(Storage_HSeqOfRoot) theDocuments=theData->Roots();
Handle(Storage_Root) theDocument;
for(Standard_Integer i=1; i<=theDocuments->Length() && theDocument.IsNull(); i++) {
theDocument=theDocuments->Value(i);
}
if(theDocument.IsNull()) {
Standard_SStream anErrorMsg;
anErrorMsg << "could not find any document in this file" << (char) 0;
myReaderStatus = PCDM_RS_NoDocument;
Standard_Failure::Raise(anErrorMsg);
}
Handle(Standard_Persistent) theObject=theDocument->Object();
Handle(PCDM_Document) thePDocument = Handle(PCDM_Document)::DownCast (theObject);
{
try {
OCC_CATCH_SIGNALS
Make(thePDocument,aNewDocument);
}
catch (Standard_Failure) {
aMsg << "Error during Make: ";
aMsg << Standard_Failure::Caught() << (char)0;
myReaderStatus = PCDM_RS_MakeFailure;
Failure=Standard_True;
}
}
// read comments
aNewDocument->SetComments(theData->Comments());
PCDM_DriverError_Raise_if(Failure,aMsg);
}
void PCDM_RetrievalDriver::References(const TCollection_ExtendedString& aFileName, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver) {
PCDM_ReadWriter::Reader(aFileName)->ReadReferences(aFileName, theReferences, theMsgDriver);
}
void PCDM_RetrievalDriver::Extensions(const TCollection_ExtendedString& aFileName, TColStd_SequenceOfExtendedString& theExtensions, const Handle(CDM_MessageDriver)& theMsgDriver) {
PCDM_ReadWriter::Reader(aFileName)->ReadExtensions(aFileName,theExtensions, theMsgDriver);
}
Standard_Integer PCDM_RetrievalDriver::DocumentVersion(const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver) {
return PCDM_ReadWriter::Reader(aFileName)->ReadDocumentVersion(aFileName, 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)&) {}
//=======================================================================
//function : Format
//purpose :
//=======================================================================
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::SetFormat (const TCollection_ExtendedString& aformat)
{
myFormat = aformat;
}
//=======================================================================
//function : Format
//purpose :
//=======================================================================
{ myFormat = aformat; }
TCollection_ExtendedString PCDM_RetrievalDriver::GetFormat () const
{
return myFormat;
}
{ return myFormat; }

71
src/PCDM/PCDM_RetrievalDriver.hxx
View File

@ -20,94 +20,49 @@
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <TCollection_ExtendedString.hxx>
#include <PCDM_Reader.hxx>
#include <PCDM_ReferenceIterator.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
#include <PCDM_SequenceOfReference.hxx>
#include <Standard_Integer.hxx>
class Standard_NoSuchObject;
class PCDM_DriverError;
class CDM_MetaData;
class TCollection_ExtendedString;
class CDM_Document;
class CDM_Application;
class PCDM_Document;
class Storage_Schema;
class CDM_MessageDriver;
class TCollection_AsciiString;
class TCollection_ExtendedString;
class PCDM_RetrievalDriver;
DEFINE_STANDARD_HANDLE(PCDM_RetrievalDriver, PCDM_Reader)
class PCDM_RetrievalDriver : public PCDM_Reader
{
friend Standard_EXPORT void PCDM_ReferenceIterator::Init (const Handle(CDM_MetaData)& aMetaData);
public:
Standard_EXPORT static Standard_Integer DocumentVersion (
const TCollection_ExtendedString& theFileName,
const Handle(CDM_MessageDriver)& theMsgDriver);
//! Warning - raises DriverError if an error occurs during inside the
//! Make method.
//! retrieves the content of the file into a new Document.
//!
//! by default Read will use the Schema method to read the file
//! into a persistent document. and the Make method to build a
//! transient document.
Standard_EXPORT virtual void Read (const TCollection_ExtendedString& aFileName, const Handle(CDM_Document)& aNewDocument, const Handle(CDM_Application)& anApplication) Standard_OVERRIDE;
Standard_EXPORT static Standard_Integer ReferenceCounter (
const TCollection_ExtendedString& theFileName,
const Handle(CDM_MessageDriver)& theMsgDriver);
Standard_EXPORT virtual void Read (Standard_IStream& theIStream,
const Handle(Storage_Data)& theStorageData,
const Handle(CDM_Document)& theDoc,
const Handle(CDM_Application)& theApplication) Standard_OVERRIDE;
Standard_EXPORT virtual void Make (const Handle(PCDM_Document)& aPCDM, const Handle(CDM_Document)& aNewDocument) = 0;
Standard_EXPORT virtual TCollection_ExtendedString SchemaName() const = 0;
Standard_EXPORT virtual void LoadExtensions (const Handle(Storage_Schema)& aSchema, const TColStd_SequenceOfExtendedString& Extensions, const Handle(CDM_MessageDriver)& theMsgDriver);
Standard_EXPORT static void RaiseIfUnknownTypes (const Handle(Storage_Schema)& aSchema, const TCollection_ExtendedString& aFileName);
Standard_EXPORT static Standard_Integer DocumentVersion (const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver);
Standard_EXPORT static Standard_Integer ReferenceCounter (const TCollection_ExtendedString& aFileName, const Handle(CDM_MessageDriver)& theMsgDriver);
Standard_EXPORT void SetFormat (const TCollection_ExtendedString& aformat);
Standard_EXPORT TCollection_ExtendedString GetFormat() const;
friend
Standard_EXPORT void PCDM_ReferenceIterator::Init (const Handle(CDM_MetaData)& aMetaData);
DEFINE_STANDARD_RTTIEXT(PCDM_RetrievalDriver,PCDM_Reader)
protected:
private:
Standard_EXPORT static void References (const TCollection_ExtendedString& aFileName, PCDM_SequenceOfReference& theReferences, const Handle(CDM_MessageDriver)& theMsgDriver);
Standard_EXPORT static void Extensions (const TCollection_ExtendedString& aFileName, TColStd_SequenceOfExtendedString& theExtensions, const Handle(CDM_MessageDriver)& theMsgDriver);
Standard_EXPORT static void UserInfo (const TCollection_ExtendedString& aFileName, const TCollection_AsciiString& Start, const TCollection_AsciiString& End, TColStd_SequenceOfExtendedString& theUserInfo, const Handle(CDM_MessageDriver)& theMsgDriver);
Standard_EXPORT static void References (
const TCollection_ExtendedString& theFileName,
PCDM_SequenceOfReference& theReferences,
const Handle(CDM_MessageDriver)& theMsgDriver);
TCollection_ExtendedString myFormat;
};
#endif // _PCDM_RetrievalDriver_HeaderFile

2
src/PCDM/PCDM_StorageDriver.cxx
View File

@ -44,7 +44,7 @@ IMPLEMENT_STANDARD_RTTIEXT(PCDM_StorageDriver,PCDM_Writer)
void PCDM_StorageDriver::Write(const Handle(CDM_Document)& aDocument, const TCollection_ExtendedString& aFileName)
{
Handle(Storage_Schema) theSchema=PCDM::Schema(SchemaName(),aDocument->Application());
Handle(Storage_Schema) theSchema = new Storage_Schema;
TColStd_SequenceOfExtendedString theExtensions;
aDocument->Extensions(theExtensions);

3
src/ShapePersistent/FILES Normal file
View File

@ -0,0 +1,3 @@
FILES
ShapePersistent.cxx
ShapePersistent.hxx

23
src/ShapePersistent/ShapePersistent.cxx Normal file
View File

@ -0,0 +1,23 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <ShapePersistent.hxx>
#include <StdObjMgt_MapOfInstantiators.hxx>
//=======================================================================
//function : BindTypes
//purpose : Register types
//=======================================================================
void ShapePersistent::BindTypes (StdObjMgt_MapOfInstantiators& /*theMap*/)
{
}

29
src/ShapePersistent/ShapePersistent.hxx Normal file
View File

@ -0,0 +1,29 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _ShapePersistent_HeaderFile
#define _ShapePersistent_HeaderFile
#include <Standard_Macro.hxx>
class StdObjMgt_MapOfInstantiators;
class ShapePersistent
{
public:
//! Register types.
Standard_EXPORT static void BindTypes (StdObjMgt_MapOfInstantiators& theMap);
};
#endif

4
src/StdDrivers/FILES Normal file
View File

@ -0,0 +1,4 @@
StdDrivers.cxx
StdDrivers.hxx
StdDrivers_DocumentRetrievalDriver.cxx
StdDrivers_DocumentRetrievalDriver.hxx

67
src/StdDrivers/StdDrivers.cxx Normal file
View File

@ -0,0 +1,67 @@
// Created on: 2000-09-07
// Created by: TURIN Anatoliy
// Copyright (c) 2000-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 <StdDrivers.hxx>
#include <StdDrivers_DocumentRetrievalDriver.hxx>
#include <StdLPersistent.hxx>
#include <StdPersistent.hxx>
#include <ShapePersistent.hxx>
#include <Standard_Failure.hxx>
#include <Standard_GUID.hxx>
#include <Plugin_Macro.hxx>
static Standard_GUID StdRetrievalDriver ("ad696001-5b34-11d1-b5ba-00a0c9064368");
//=======================================================================
//function : Factory
//purpose : Depending from the ID, returns a list of storage
// or retrieval attribute drivers. Used for plugin
//=======================================================================
Handle(Standard_Transient) StdDrivers::Factory (const Standard_GUID& aGUID)
{
if (aGUID == StdRetrievalDriver)
{
#ifdef OCCT_DEBUG
cout << "StdDrivers : Retrieval Plugin" << endl;
#endif
static Handle(StdDrivers_DocumentRetrievalDriver) model_rd = new StdDrivers_DocumentRetrievalDriver;
return model_rd;
}
Standard_Failure::Raise ("StdDrivers : unknown GUID");
return NULL;
}
//=======================================================================
//function : BindTypes
//purpose : Register types
//=======================================================================
void StdDrivers::BindTypes (StdObjMgt_MapOfInstantiators& theMap)
{
StdLPersistent ::BindTypes (theMap);
StdPersistent ::BindTypes (theMap);
ShapePersistent::BindTypes (theMap);
}
#ifdef _MSC_VER
#pragma warning(disable:4190) /* disable warning on C++ type returned by C function; should be OK for C++ usage */
#endif
// Declare entry point PLUGINFACTORY
PLUGIN (StdDrivers)

41
src/StdDrivers/StdDrivers.hxx Normal file
View File

@ -0,0 +1,41 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdDrivers_HeaderFile
#define _StdDrivers_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class Standard_Transient;
class Standard_GUID;
class StdObjMgt_MapOfInstantiators;
class StdDrivers
{
friend class StdDrivers_DocumentRetrievalDriver;
public:
//! Depending from the ID, returns a list of storage
//! or retrieval attribute drivers. Used for plugin
Standard_EXPORT static Handle(Standard_Transient) Factory (const Standard_GUID& aGUID);
//! Register types.
Standard_EXPORT static void BindTypes (StdObjMgt_MapOfInstantiators& theMap);
DEFINE_STANDARD_ALLOC
};
#endif // _StdDrivers_HeaderFile

26
src/StdDrivers/StdDrivers_DocumentRetrievalDriver.cxx Normal file
View File

@ -0,0 +1,26 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdDrivers_DocumentRetrievalDriver.hxx>
#include <StdDrivers.hxx>
IMPLEMENT_STANDARD_RTTIEXT (StdDrivers_DocumentRetrievalDriver, StdLDrivers_DocumentRetrievalDriver)
//=======================================================================
//function : BindTypes
//purpose : Register types
//=======================================================================
void StdDrivers_DocumentRetrievalDriver::BindTypes (StdObjMgt_MapOfInstantiators& theMap)
{
StdDrivers::BindTypes (theMap);
}

29
src/StdDrivers/StdDrivers_DocumentRetrievalDriver.hxx Normal file
View File

@ -0,0 +1,29 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdDrivers_DocumentRetrievalDriver_HeaderFile
#define _StdDrivers_DocumentRetrievalDriver_HeaderFile
#include <StdLDrivers_DocumentRetrievalDriver.hxx>
//! retrieval driver of a Part document
class StdDrivers_DocumentRetrievalDriver : public StdLDrivers_DocumentRetrievalDriver
{
public:
//! Register types.
Standard_EXPORT virtual void BindTypes (StdObjMgt_MapOfInstantiators& theMap);
DEFINE_STANDARD_RTTIEXT (StdDrivers_DocumentRetrievalDriver, StdLDrivers_DocumentRetrievalDriver)
};
#endif // _StdDrivers_DocumentRetrievalDriver_HeaderFile

4
src/StdLDrivers/FILES Normal file
View File

@ -0,0 +1,4 @@
StdLDrivers.cxx
StdLDrivers.hxx
StdLDrivers_DocumentRetrievalDriver.cxx
StdLDrivers_DocumentRetrievalDriver.hxx

61
src/StdLDrivers/StdLDrivers.cxx Normal file
View File

@ -0,0 +1,61 @@
// Created on: 2000-09-07
// Created by: TURIN Anatoliy
// Copyright (c) 2000-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 <StdLDrivers.hxx>
#include <StdLDrivers_DocumentRetrievalDriver.hxx>
#include <StdLPersistent.hxx>
#include <Standard_Failure.hxx>
#include <Standard_GUID.hxx>
#include <Plugin_Macro.hxx>
static Standard_GUID StdLRetrievalDriver ("bd696001-5b34-11d1-b5ba-00a0c9064368");
//=======================================================================
//function : Factory
//purpose : Depending from the ID, returns a list of storage
// or retrieval attribute drivers. Used for plugin
//=======================================================================
Handle(Standard_Transient) StdLDrivers::Factory (const Standard_GUID& aGUID)
{
if (aGUID == StdLRetrievalDriver)
{
#ifdef OCCT_DEBUG
cout << "StdLDrivers : Retrieval Plugin" << endl;
#endif
static Handle(StdLDrivers_DocumentRetrievalDriver) model_rd = new StdLDrivers_DocumentRetrievalDriver;
return model_rd;
}
Standard_Failure::Raise ("StdLDrivers : unknown GUID");
return NULL;
}
//=======================================================================
//function : BindTypes
//purpose : Register types
//=======================================================================
void StdLDrivers::BindTypes (StdObjMgt_MapOfInstantiators& theMap)
{
StdLPersistent::BindTypes (theMap);
}
#ifdef _MSC_VER
#pragma warning(disable:4190) /* disable warning on C++ type returned by C function; should be OK for C++ usage */
#endif
// Declare entry point PLUGINFACTORY
PLUGIN (StdLDrivers)

41
src/StdLDrivers/StdLDrivers.hxx Normal file
View File

@ -0,0 +1,41 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLDrivers_HeaderFile
#define _StdLDrivers_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class Standard_Transient;
class Standard_GUID;
class StdObjMgt_MapOfInstantiators;
class StdLDrivers
{
friend class StdLDrivers_DocumentRetrievalDriver;
public:
//! Depending from the ID, returns a list of storage
//! or retrieval attribute drivers. Used for plugin
Standard_EXPORT static Handle(Standard_Transient) Factory (const Standard_GUID& aGUID);
//! Register types.
Standard_EXPORT static void BindTypes (StdObjMgt_MapOfInstantiators& theMap);
DEFINE_STANDARD_ALLOC
};
#endif // _StdLDrivers_HeaderFile

310
src/StdLDrivers/StdLDrivers_DocumentRetrievalDriver.cxx Normal file
View File

@ -0,0 +1,310 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdLDrivers_DocumentRetrievalDriver.hxx>
#include <StdLDrivers.hxx>
#include <StdLPersistent_PDocStd_Document.hxx>
#include <StdObjMgt_MapOfInstantiators.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <Storage_HeaderData.hxx>
#include <Storage_TypeData.hxx>
#include <Storage_RootData.hxx>
#include <Storage_BaseDriver.hxx>
#include <Storage_StreamTypeMismatchError.hxx>
#include <Storage_StreamFormatError.hxx>
#include <Storage_StreamReadError.hxx>
#include <PCDM.hxx>
#include <PCDM_ReadWriter.hxx>
#include <Standard_ErrorHandler.hxx>
#include <NCollection_Array1.hxx>
#include <TDocStd_Document.hxx>
IMPLEMENT_STANDARD_RTTIEXT (StdLDrivers_DocumentRetrievalDriver, PCDM_RetrievalDriver)
//=======================================================================
//function : CreateDocument
//purpose : Create an empty TDocStd_Document
//=======================================================================
Handle(CDM_Document) StdLDrivers_DocumentRetrievalDriver::CreateDocument()
{
return new TDocStd_Document (PCDM_RetrievalDriver::GetFormat());
}
//=======================================================================
//function : Read
//purpose : Retrieve the content of a file into a new document
//=======================================================================
void StdLDrivers_DocumentRetrievalDriver::Read (const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)&)
{
Standard_Integer i;
// Create a driver appropriate for the given file
PCDM_BaseDriverPointer aFileDriver;
if (PCDM::FileDriverType (TCollection_AsciiString (theFileName), aFileDriver) == PCDM_TOFD_Unknown)
{
myReaderStatus = PCDM_RS_UnknownFileDriver;
return;
}
// Try to open the file
{
Standard_SStream aMsg;
try
{
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open (*aFileDriver, theFileName, Storage_VSRead);
myReaderStatus = PCDM_RS_OK;
}
catch (Standard_Failure)
{
aMsg << Standard_Failure::Caught() << endl;
myReaderStatus = PCDM_RS_OpenError;
}
if (myReaderStatus != PCDM_RS_OK)
{
Standard_Failure::Raise (aMsg);
return;
}
}
// Read header section
Storage_HeaderData hData;
if (!hData.Read (*aFileDriver))
{
RaiseOnStorageError (hData.ErrorStatus());
return;
}
// Read type section
Storage_TypeData tData;
if (!tData.Read (*aFileDriver))
{
RaiseOnStorageError (tData.ErrorStatus());
return;
}
// Read root section
Storage_RootData rData;
if (!rData.Read (*aFileDriver))
{
RaiseOnStorageError (rData.ErrorStatus());
return;
}
if (rData.NumberOfRoots() < 1)
{
myReaderStatus = PCDM_RS_NoDocument;
Standard_SStream aMsg;
aMsg << "could not find any document in this file" << endl;
Standard_Failure::Raise (aMsg);
return;
}
// Select instantiators for the used types
NCollection_Array1<StdObjMgt_Persistent::Instantiator>
anInstantiators (1, tData.NumberOfTypes());
{
StdObjMgt_MapOfInstantiators aMapOfInstantiators;
BindTypes (aMapOfInstantiators);
TColStd_SequenceOfAsciiString anUnknownTypes;
Standard_Integer aCurTypeNum;
TCollection_AsciiString aCurTypeName;
for (i = 1; i <= tData.NumberOfTypes(); i++)
{
aCurTypeName = tData.Type (i);
aCurTypeNum = tData.Type (aCurTypeName);
StdObjMgt_Persistent::Instantiator anInstantiator;
if (aMapOfInstantiators.Find (aCurTypeName, anInstantiator))
anInstantiators (aCurTypeNum) = anInstantiator;
else
anUnknownTypes.Append (aCurTypeName);
}
if (!anUnknownTypes.IsEmpty())
{
myReaderStatus = PCDM_RS_TypeNotFoundInSchema;
Standard_SStream aMsg;
aMsg << "cannot read: `" << theFileName
<< "' because it contains the following unknown types: ";
for (i = 1; i <= anUnknownTypes.Length(); i++)
{
aMsg << anUnknownTypes(i);
if (i < anUnknownTypes.Length()) aMsg << ",";
else aMsg << endl;
}
Standard_Failure::Raise (aMsg);
return;
}
}
// Read and parse reference section
StdObjMgt_ReadData aReadData (*aFileDriver, hData.NumberOfObjects());
if (RaiseOnStorageError (aFileDriver->BeginReadRefSection()))
return;
Standard_Integer len = aFileDriver->RefSectionSize();
for (i = 1; i <= len; i++)
{
Standard_Integer aRef = 0, aType = 0;
Storage_Error anError;
try
{
OCC_CATCH_SIGNALS
aFileDriver->ReadReferenceType (aRef, aType);
anError = Storage_VSOk;
}
catch (Storage_StreamTypeMismatchError)
{
anError = Storage_VSTypeMismatch;
}
if (RaiseOnStorageError (anError))
return;
aReadData.CreateObject (aRef, anInstantiators (aType));
}
if (RaiseOnStorageError (aFileDriver->EndReadRefSection()))
return;
// Read and parse data section
if (RaiseOnStorageError (aFileDriver->BeginReadDataSection()))
return;
for (i = 1; i <= hData.NumberOfObjects(); i++)
{
Handle(StdObjMgt_Persistent) aPersistent = aReadData.Object (i);
if (!aPersistent.IsNull())
{
Standard_Integer aRef = 0, aType = 0;
Storage_Error anError;
try
{
OCC_CATCH_SIGNALS
aFileDriver->ReadPersistentObjectHeader (aRef, aType);
aFileDriver->BeginReadPersistentObjectData();
aPersistent->Read (aReadData);
aFileDriver->EndReadPersistentObjectData();
anError = Storage_VSOk;
}
catch (Storage_StreamTypeMismatchError) { anError = Storage_VSTypeMismatch; }
catch (Storage_StreamFormatError ) { anError = Storage_VSFormatError; }
catch (Storage_StreamReadError ) { anError = Storage_VSFormatError; }
if (RaiseOnStorageError (anError))
return;
}
}
if (RaiseOnStorageError (aFileDriver->EndReadDataSection()))
return;
// Close the file
aFileDriver->Close();
delete aFileDriver;
// Initialize transient document using the root object and comments
Handle(Storage_HSeqOfRoot) aRoots = rData.Roots();
Handle(Storage_Root) aFirstRoot = aRoots->First();
Handle(StdObjMgt_Persistent) aFirstRootObject =
aReadData.Object (aFirstRoot->Reference());
Handle(StdLPersistent_PDocStd_Document) aPDocument =
Handle(StdLPersistent_PDocStd_Document)::DownCast (aFirstRootObject);
if (!aPDocument.IsNull())
aPDocument->Import (theNewDocument);
theNewDocument->SetComments (hData.Comments());
}
//=======================================================================
//function : RaiseOnStorageError
//purpose : Update the reader status and raise an exception
// appropriate for the given storage error
//=======================================================================
Standard_Boolean StdLDrivers_DocumentRetrievalDriver::RaiseOnStorageError (Storage_Error theError)
{
Standard_SStream aMsg;
switch (theError)
{
case Storage_VSOk:
return Standard_False;
case Storage_VSOpenError:
case Storage_VSNotOpen:
case Storage_VSAlreadyOpen:
myReaderStatus = PCDM_RS_OpenError;
aMsg << "Stream Open Error" << endl;
break;
case Storage_VSModeError:
myReaderStatus = PCDM_RS_WrongStreamMode;
aMsg << "Stream is opened with a wrong mode for operation" << endl;
break;
case Storage_VSSectionNotFound:
myReaderStatus = PCDM_RS_FormatFailure;
aMsg << "Section is not found" << endl;
break;
case Storage_VSFormatError:
myReaderStatus = PCDM_RS_FormatFailure;
aMsg << "Wrong format error" << endl;
break;
case Storage_VSUnknownType:
myReaderStatus = PCDM_RS_TypeFailure;
aMsg << "Try to read an unknown type" << endl;
break;
case Storage_VSTypeMismatch:
myReaderStatus = PCDM_RS_TypeFailure;
aMsg << "Try to read a wrong primitive type" << endl;
break;
default:
myReaderStatus = PCDM_RS_DriverFailure;
aMsg << "Retrieval Driver Failure" << endl;
}
Standard_Failure::Raise (aMsg);
return Standard_True;
}
//=======================================================================
//function : BindTypes
//purpose : Register types
//=======================================================================
void StdLDrivers_DocumentRetrievalDriver::BindTypes (StdObjMgt_MapOfInstantiators& theMap)
{
StdLDrivers::BindTypes (theMap);
}

44
src/StdLDrivers/StdLDrivers_DocumentRetrievalDriver.hxx Normal file
View File

@ -0,0 +1,44 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLDrivers_DocumentRetrievalDriver_HeaderFile
#define _StdLDrivers_DocumentRetrievalDriver_HeaderFile
#include <PCDM_RetrievalDriver.hxx>
#include <Storage_Error.hxx>
class StdObjMgt_MapOfInstantiators;
//! retrieval driver of a Part document
class StdLDrivers_DocumentRetrievalDriver : public PCDM_RetrievalDriver
{
public:
//! Create an empty TDocStd_Document.
Standard_EXPORT virtual Handle(CDM_Document) CreateDocument();
//! Retrieve the content of a file into a new document.
Standard_EXPORT virtual void Read (const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication);
DEFINE_STANDARD_RTTIEXT (StdLDrivers_DocumentRetrievalDriver, PCDM_RetrievalDriver)
private:
//! Update the reader status and raise an exception appropriate for the given storage error.
Standard_EXPORT Standard_Boolean RaiseOnStorageError (Storage_Error theError);
//! Register types.
Standard_EXPORT virtual void BindTypes (StdObjMgt_MapOfInstantiators& theMap);
};
#endif // _StdLDrivers_DocumentRetrievalDriver_HeaderFile

16
src/StdLPersistent/FILES Normal file
View File

@ -0,0 +1,16 @@
FILES
StdLPersistent.cxx
StdLPersistent.hxx
StdLPersistent_PCollection_HExtendedString.cxx
StdLPersistent_PCollection_HExtendedString.hxx
StdLPersistent_PColStd_HArray1.hxx
StdLPersistent_PColStd_HArray1Base.cxx
StdLPersistent_PColStd_HArray1Base.hxx
StdLPersistent_PDataStd_Integer.cxx
StdLPersistent_PDataStd_Integer.hxx
StdLPersistent_PDataStd_Name.cxx
StdLPersistent_PDataStd_Name.hxx
StdLPersistent_PDF_Data.cxx
StdLPersistent_PDF_Data.hxx
StdLPersistent_PDocStd_Document.cxx
StdLPersistent_PDocStd_Document.hxx

43
src/StdLPersistent/StdLPersistent.cxx Normal file
View File

@ -0,0 +1,43 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdLPersistent.hxx>
#include <StdObjMgt_MapOfInstantiators.hxx>
#include <StdLPersistent_PDocStd_Document.hxx>
#include <StdLPersistent_PDF_Data.hxx>
#include <StdLPersistent_PColStd_HArray1.hxx>
#include <StdLPersistent_PCollection_HExtendedString.hxx>
#include <StdLPersistent_PDataStd_Name.hxx>
#include <StdLPersistent_PDataStd_Integer.hxx>
//=======================================================================
//function : BindTypes
//purpose : Register types
//=======================================================================
void StdLPersistent::BindTypes (StdObjMgt_MapOfInstantiators& theMap)
{
theMap.Bind <StdLPersistent_PDocStd_Document> ("PDocStd_Document");
theMap.Bind <StdLPersistent_PDF_Data> ("PDF_Data");
theMap.Bind <StdLPersistent_PDataStd_Name> ("PDataStd_Name");
theMap.Bind <StdLPersistent_PDataStd_Integer> ("PDataStd_Integer");
theMap.Bind <StdLPersistent_PColStd_HArray1OfInteger>
("PColStd_HArray1OfInteger");
theMap.Bind <StdLPersistent_PDF_HAttributeArray1>
("PDF_HAttributeArray1");
theMap.Bind <StdLPersistent_PCollection_HExtendedString>
("PCollection_HExtendedString");
}

29
src/StdLPersistent/StdLPersistent.hxx Normal file
View File

@ -0,0 +1,29 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLPersistent_HeaderFile
#define _StdLPersistent_HeaderFile
#include <Standard_Macro.hxx>
class StdObjMgt_MapOfInstantiators;
class StdLPersistent
{
public:
//! Register types.
Standard_EXPORT static void BindTypes (StdObjMgt_MapOfInstantiators& theMap);
};
#endif

62
src/StdLPersistent/StdLPersistent_PColStd_HArray1.hxx Normal file
View File

@ -0,0 +1,62 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLPersistent_PColStd_HArray1_HeaderFile
#define _StdLPersistent_PColStd_HArray1_HeaderFile
#include <StdLPersistent_PColStd_HArray1Base.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <NCollection_Handle.hxx>
#include <NCollection_Array1.hxx>
#include <Standard_TypeDef.hxx>
class StdObjMgt_Persistent;
template <class Type>
class StdLPersistent_PColStd_HArray1 : public StdLPersistent_PColStd_HArray1Base
{
public:
//! Get the value.
const NCollection_Array1<Type>& Array() const { return *myArray; }
protected:
virtual void CreateArray (const Standard_Integer theLowerBound,
const Standard_Integer theUpperBound)
{
myArray = new NCollection_Array1<Type> (theLowerBound, theUpperBound);
}
virtual void ReadValue (StdObjMgt_ReadData& theReadData,
const Standard_Integer theIndex)
{
Type aValue;
theReadData >> aValue;
myArray->SetValue (theIndex, aValue);
}
private:
NCollection_Handle<NCollection_Array1<Type>> myArray;
};
typedef StdLPersistent_PColStd_HArray1<Standard_Integer>
StdLPersistent_PColStd_HArray1OfInteger;
typedef StdLPersistent_PColStd_HArray1<Handle(StdObjMgt_Persistent)>
StdLPersistent_PDF_HAttributeArray1;
#endif

37
src/StdLPersistent/StdLPersistent_PColStd_HArray1Base.cxx Normal file
View File

@ -0,0 +1,37 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdLPersistent_PColStd_HArray1Base.hxx>
#include <StdObjMgt_ReadData.hxx>
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
//=======================================================================
void StdLPersistent_PColStd_HArray1Base::Read (StdObjMgt_ReadData& theReadData)
{
Standard_Integer aLowerBound, anUpperBound;
theReadData >> aLowerBound >> anUpperBound;
CreateArray (aLowerBound, anUpperBound);
theReadData.Driver().BeginReadObjectData();
Standard_Integer aSize;
theReadData >> aSize;
for (Standard_Integer i = aLowerBound; i <= anUpperBound; i++)
ReadValue (theReadData, i);
theReadData.Driver().EndReadObjectData();
}

35
src/StdLPersistent/StdLPersistent_PColStd_HArray1Base.hxx Normal file
View File

@ -0,0 +1,35 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLPersistent_PColStd_HArray1Base_HeaderFile
#define _StdLPersistent_PColStd_HArray1Base_HeaderFile
#include <StdObjMgt_Persistent.hxx>
class StdLPersistent_PColStd_HArray1Base : public StdObjMgt_Persistent
{
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
protected:
virtual void CreateArray (const Standard_Integer theLowerBound,
const Standard_Integer theUpperBound) = 0;
virtual void ReadValue (StdObjMgt_ReadData& theReadData,
const Standard_Integer theIndex) = 0;
};
#endif

40
src/StdLPersistent/StdLPersistent_PCollection_HExtendedString.cxx Normal file
View File

@ -0,0 +1,40 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdLPersistent_PCollection_HExtendedString.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <TCollection_HExtendedString.hxx>
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
//=======================================================================
void StdLPersistent_PCollection_HExtendedString::Read (StdObjMgt_ReadData& theReadData)
{
theReadData.Driver().BeginReadObjectData();
Standard_Integer aSize;
theReadData >> aSize;
myValue = new TCollection_HExtendedString (aSize, 0);
for (Standard_Integer i = 1; i <= aSize; i++)
{
Standard_ExtCharacter aChar;
theReadData >> aChar;
myValue->SetValue (i, aChar);
}
theReadData.Driver().EndReadObjectData();
}

36
src/StdLPersistent/StdLPersistent_PCollection_HExtendedString.hxx Normal file
View File

@ -0,0 +1,36 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLPersistent_PCollection_HExtendedString_HeaderFile
#define _StdLPersistent_PCollection_HExtendedString_HeaderFile
#include <StdObjMgt_Persistent.hxx>
class TCollection_HExtendedString;
class StdLPersistent_PCollection_HExtendedString : public StdObjMgt_Persistent
{
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Get the value.
Handle(TCollection_HExtendedString) Value() const { return myValue; }
private:
Handle(TCollection_HExtendedString) myValue;
};
#endif

98
src/StdLPersistent/StdLPersistent_PDF_Data.cxx Normal file
View File

@ -0,0 +1,98 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdLPersistent_PDF_Data.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <TDF_Data.hxx>
#include <TDF_Attribute.hxx>
//! Create a transient label tree from persistent data
class StdLPersistent_PDF_Data::Parser
{
public:
//! Start parsing a persistent data.
Parser (const StdLPersistent_PDF_Data& theSource)
: myLabelsIter (theSource.myLabels->Array())
, myAttribIter (theSource.myAttributes->Array()) {}
//! Fill a transient label with data.
void FillLabel (TDF_Label theLabel)
{
Standard_Integer i;
// Read count of attributes
myLabelsIter.Next();
Standard_Integer anAttribCount = myLabelsIter.Value();
// Add attributes to the label
for (i = 0 ; i < anAttribCount; i++)
{
// read persistent attribute
const Handle(StdObjMgt_Persistent)& aPAttrib = myAttribIter.Value();
myAttribIter.Next();
// create transient attribute and add it to the label
if (!aPAttrib.IsNull())
{
Handle(TDF_Attribute) aTAttrib = aPAttrib->ImportAttribute();
if (!aTAttrib.IsNull())
theLabel.AddAttribute (aTAttrib);
}
}
// Read count of child labels
myLabelsIter.Next();
Standard_Integer aSubLabelsCount = myLabelsIter.Value();
// Create child labels
for (i = 0 ; i < aSubLabelsCount; i++)
{
// read tag of child label
myLabelsIter.Next();
Standard_Integer aSubLabelTag = myLabelsIter.Value();
// create and fill child label
TDF_Label aSubLabel = theLabel.FindChild (aSubLabelTag, Standard_True);
FillLabel (aSubLabel);
}
}
private:
NCollection_Array1<Standard_Integer >::Iterator myLabelsIter;
NCollection_Array1<Handle(StdObjMgt_Persistent)>::Iterator myAttribIter;
};
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
//=======================================================================
void StdLPersistent_PDF_Data::Read (StdObjMgt_ReadData& theReadData)
{
theReadData >> myVersion >> myLabels >> myAttributes;
}
//=======================================================================
//function : Import
//purpose : Import transient data from the persistent data
//=======================================================================
Handle(TDF_Data) StdLPersistent_PDF_Data::Import() const
{
if (myLabels.IsNull() || myAttributes.IsNull())
return NULL;
Handle(TDF_Data) aData = new TDF_Data;
Parser (*this).FillLabel (aData->Root());
return aData;
}

43
src/StdLPersistent/StdLPersistent_PDF_Data.hxx Normal file
View File

@ -0,0 +1,43 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLPersistent_PDF_Data_HeaderFile
#define _StdLPersistent_PDF_Data_HeaderFile
#include <StdObjMgt_Persistent.hxx>
#include <StdLPersistent_PColStd_HArray1.hxx>
class TDF_Data;
class StdLPersistent_PDF_Data : public StdObjMgt_Persistent
{
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Import transient data from the persistent data.
Standard_EXPORT Handle(TDF_Data) Import() const;
private:
class Parser;
private:
Standard_Integer myVersion;
Handle(StdLPersistent_PColStd_HArray1OfInteger) myLabels;
Handle(StdLPersistent_PDF_HAttributeArray1) myAttributes;
};
#endif

38
src/StdLPersistent/StdLPersistent_PDataStd_Integer.cxx Normal file
View File

@ -0,0 +1,38 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdLPersistent_PDataStd_Integer.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <TDataStd_Integer.hxx>
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
//=======================================================================
void StdLPersistent_PDataStd_Integer::Read (StdObjMgt_ReadData& theReadData)
{
theReadData >> myValue;
}
//=======================================================================
//function : ImportAttribute
//purpose : Import transient attribuite from the persistent data
//=======================================================================
Handle(TDF_Attribute) StdLPersistent_PDataStd_Integer::ImportAttribute() const
{
Handle(TDataStd_Integer) aValue = new TDataStd_Integer;
aValue->Set (myValue);
return aValue;
}

34
src/StdLPersistent/StdLPersistent_PDataStd_Integer.hxx Normal file
View File

@ -0,0 +1,34 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLPersistent_PDataStd_Integer_HeaderFile
#define _StdLPersistent_PDataStd_Integer_HeaderFile
#include <StdObjMgt_Persistent.hxx>
class StdLPersistent_PDataStd_Integer : public StdObjMgt_Persistent
{
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Import transient attribuite from the persistent data.
Standard_EXPORT virtual Handle(TDF_Attribute) ImportAttribute() const;
private:
Standard_Integer myValue;
};
#endif

43
src/StdLPersistent/StdLPersistent_PDataStd_Name.cxx Normal file
View File

@ -0,0 +1,43 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdLPersistent_PDataStd_Name.hxx>
#include <StdLPersistent_PCollection_HExtendedString.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <TCollection_HExtendedString.hxx>
#include <TDataStd_Name.hxx>
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
//=======================================================================
void StdLPersistent_PDataStd_Name::Read (StdObjMgt_ReadData& theReadData)
{
theReadData >> myString;
}
//=======================================================================
//function : ImportAttribute
//purpose : Import transient attribuite from the persistent data
//=======================================================================
Handle(TDF_Attribute) StdLPersistent_PDataStd_Name::ImportAttribute() const
{
if (myString.IsNull() || myString->Value().IsNull())
return NULL;
Handle(TDataStd_Name) aName = new TDataStd_Name;
aName->Set (myString->Value()->String());
return aName;
}

36
src/StdLPersistent/StdLPersistent_PDataStd_Name.hxx Normal file
View File

@ -0,0 +1,36 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLPersistent_PDataStd_Name_HeaderFile
#define _StdLPersistent_PDataStd_Name_HeaderFile
#include <StdObjMgt_Persistent.hxx>
class StdLPersistent_PCollection_HExtendedString;
class StdLPersistent_PDataStd_Name : public StdObjMgt_Persistent
{
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Import transient attribuite from the persistent data.
Standard_EXPORT virtual Handle(TDF_Attribute) ImportAttribute() const;
private:
Handle(StdLPersistent_PCollection_HExtendedString) myString;
};
#endif

44
src/StdLPersistent/StdLPersistent_PDocStd_Document.cxx Normal file
View File

@ -0,0 +1,44 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdLPersistent_PDocStd_Document.hxx>
#include <StdLPersistent_PDF_Data.hxx>
#include <StdObjMgt_ReadData.hxx>
#include <TDocStd_Document.hxx>
#include <TDocStd_Owner.hxx>
//=======================================================================
//function : Read
//purpose : Read persistent data from a file
//=======================================================================
void StdLPersistent_PDocStd_Document::Read (StdObjMgt_ReadData& theReadData)
{
theReadData >> myData;
}
//=======================================================================
//function : Import
//purpose : Import transient document from the persistent data
//=======================================================================
void StdLPersistent_PDocStd_Document::Import (const Handle(CDM_Document)& theDocument) const
{
Handle(TDocStd_Document) aDocument = Handle(TDocStd_Document)::DownCast (theDocument);
if (aDocument.IsNull() || myData.IsNull())
return;
Handle(TDF_Data) aData = myData->Import();
aDocument->SetData (aData);
TDocStd_Owner::SetDocument (aData, aDocument);
}

37
src/StdLPersistent/StdLPersistent_PDocStd_Document.hxx Normal file
View File

@ -0,0 +1,37 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdLPersistent_PDocStd_Document_HeaderFile
#define _StdLPersistent_PDocStd_Document_HeaderFile
#include <StdObjMgt_Persistent.hxx>
class CDM_Document;
class StdLPersistent_PDF_Data;
class StdLPersistent_PDocStd_Document : public StdObjMgt_Persistent
{
public:
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData);
//! Import transient document from the persistent data.
Standard_EXPORT void Import (const Handle(CDM_Document)& theDocument) const;
private:
Handle(StdLPersistent_PDF_Data) myData;
};
#endif

6
src/StdObjMgt/FILES Normal file
View File

@ -0,0 +1,6 @@
StdObjMgt_MapOfInstantiators.cxx
StdObjMgt_MapOfInstantiators.hxx
StdObjMgt_Persistent.cxx
StdObjMgt_Persistent.hxx
StdObjMgt_ReadData.cxx
StdObjMgt_ReadData.hxx

15
src/StdObjMgt/StdObjMgt_MapOfInstantiators.cxx Normal file
View File

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

45
src/StdObjMgt/StdObjMgt_MapOfInstantiators.hxx Normal file
View File

@ -0,0 +1,45 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdObjMgt_MapOfInstantiators_HeaderFile
#define _StdObjMgt_MapOfInstantiators_HeaderFile
#include <StdObjMgt_Persistent.hxx>
#include <NCollection_DataMap.hxx>
#include <TCollection_AsciiString.hxx>
class StdObjMgt_MapOfInstantiators
: public NCollection_DataMap<TCollection_AsciiString,
StdObjMgt_Persistent::Instantiator,
TCollection_AsciiString>
{
public:
template <class Type>
void Bind (const TCollection_AsciiString& theTypeName)
{
NCollection_DataMap<TCollection_AsciiString,
StdObjMgt_Persistent::Instantiator,
TCollection_AsciiString>
::Bind (theTypeName, &Instantiate<Type>);
}
DEFINE_STANDARD_ALLOC
private:
template <class Type>
static Handle(StdObjMgt_Persistent) Instantiate()
{ return new Type; }
};
#endif // _StdObjMgt_MapOfInstantiators_HeaderFile

25
src/StdObjMgt/StdObjMgt_Persistent.cxx Normal file
View File

@ -0,0 +1,25 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdObjMgt_Persistent.hxx>
//=======================================================================
//function : ImportAttribute
//purpose : Import transient attribuite from the persistent data
//! (to be overriden by attribute classes;
//! returns a null handle by default for non-attribute classes)
//=======================================================================
Handle(TDF_Attribute) StdObjMgt_Persistent::ImportAttribute() const
{
return Handle(TDF_Attribute)();
}

43
src/StdObjMgt/StdObjMgt_Persistent.hxx Normal file
View File

@ -0,0 +1,43 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdObjMgt_Persistent_HeaderFile
#define _StdObjMgt_Persistent_HeaderFile
#include <Standard.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Transient.hxx>
class StdObjMgt_ReadData;
class TDF_Attribute;
//! Root class for a temporary object that reads data from a file and then
//! creates transient object using the data.
class StdObjMgt_Persistent : public Standard_Transient
{
public:
//! Create a derived class instance.
typedef Handle(StdObjMgt_Persistent) (*Instantiator)();
//! Read persistent data from a file.
Standard_EXPORT virtual void Read (StdObjMgt_ReadData& theReadData) = 0;
//! Import transient attribuite from the persistent data
//! (to be overriden by attribute classes;
//! returns a null handle by default for non-attribute classes).
Standard_EXPORT virtual Handle(TDF_Attribute) ImportAttribute() const;
};
#endif // _StdObjMgt_Persistent_HeaderFile

31
src/StdObjMgt/StdObjMgt_ReadData.cxx Normal file
View File

@ -0,0 +1,31 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdObjMgt_ReadData.hxx>
StdObjMgt_ReadData::StdObjMgt_ReadData (Storage_BaseDriver& theDriver,
const Standard_Integer theNumberOfObjects)
: myDriver (&theDriver)
, myPersistentObjects (1, theNumberOfObjects) {}
void StdObjMgt_ReadData::ReadReference (Handle(StdObjMgt_Persistent)& theTarget)
{
Standard_Integer aRef;
myDriver->GetReference (aRef);
if (aRef)
theTarget = Object (aRef);
else
theTarget.Nullify();
}

61
src/StdObjMgt/StdObjMgt_ReadData.hxx Normal file
View File

@ -0,0 +1,61 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdObjMgt_ReadData_HeaderFile
#define _StdObjMgt_ReadData_HeaderFile
#include <Standard.hxx>
#include <StdObjMgt_Persistent.hxx>
#include <NCollection_Array1.hxx>
#include <Storage_BaseDriver.hxx>
//! Auxiliary data used to read persistent objects from a file.
class StdObjMgt_ReadData
{
public:
Standard_EXPORT StdObjMgt_ReadData (Storage_BaseDriver& theDriver,
const Standard_Integer theNumberOfObjects);
void CreateObject (const Standard_Integer theRef,
StdObjMgt_Persistent::Instantiator theInstantiator)
{ myPersistentObjects (theRef) = theInstantiator(); }
Handle(StdObjMgt_Persistent) Object (const Standard_Integer theRef) const
{ return myPersistentObjects (theRef); }
Storage_BaseDriver& Driver() const
{ return *myDriver; }
Standard_EXPORT void ReadReference (Handle(StdObjMgt_Persistent)& theTarget);
template <class Type>
StdObjMgt_ReadData& operator >> (Type& aValue)
{
*myDriver >> aValue;
return *this;
}
template <class Type>
StdObjMgt_ReadData& operator >> (Handle(Type)& theTarget)
{
ReadReference (theTarget);
return *this;
}
private:
Storage_BaseDriver* myDriver;
NCollection_Array1<Handle(StdObjMgt_Persistent)> myPersistentObjects;
};
#endif // _StdObjMgt_ReadData_HeaderFile

3
src/StdPersistent/FILES Normal file
View File

@ -0,0 +1,3 @@
FILES
StdPersistent.cxx
StdPersistent.hxx

23
src/StdPersistent/StdPersistent.cxx Normal file
View File

@ -0,0 +1,23 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <StdPersistent.hxx>
#include <StdObjMgt_MapOfInstantiators.hxx>
//=======================================================================
//function : BindTypes
//purpose : Register types
//=======================================================================
void StdPersistent::BindTypes (StdObjMgt_MapOfInstantiators& /*theMap*/)
{
}

29
src/StdPersistent/StdPersistent.hxx Normal file
View File

@ -0,0 +1,29 @@
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _StdPersistent_HeaderFile
#define _StdPersistent_HeaderFile
#include <Standard_Macro.hxx>
class StdObjMgt_MapOfInstantiators;
class StdPersistent
{
public:
//! Register types.
Standard_EXPORT static void BindTypes (StdObjMgt_MapOfInstantiators& theMap);
};
#endif

8
src/StdResource/Plugin
View File

@ -3,6 +3,14 @@
!
a148e300-5740-11d1-a904-080036aaa103.Location: FWOSPlugin
!
! standard attribute drivers plugin
!
ad696001-5b34-11d1-b5ba-00a0c9064368.Location: TKStd
!
! standard attribute drivers plugin
!
bd696001-5b34-11d1-b5ba-00a0c9064368.Location: TKStdL
!
! XmlOcaf Document Plugin
!
03a56820-8269-11d5-aab2-0050044b1af1.Location: TKXml

8
src/StdResource/Standard
View File

@ -1,9 +1,15 @@
formatlist:XmlOcaf|BinOcaf
formatlist:MDTV-Standard|XmlOcaf|BinOcaf
!
! Default format
xml.FileFormat: XmlOcaf
cbf.FileFormat: BinOcaf
!
! standard attributes
!
MDTV-Standard.Description: Standard Document Version 1.0
MDTV-Standard.FileExtension: std
MDTV-Standard.RetrievalPlugin: ad696001-5b34-11d1-b5ba-00a0c9064368
!
! XmlOcaf format
!
XmlOcaf.Description: Xml Document Version 1.0

9
src/StdResource/StandardLite
View File

@ -1,4 +1,11 @@
formatlist:BinLOcaf|XmlLOcaf
formatlist:OCC-StdLite|BinLOcaf|XmlLOcaf
!
!
! Lite attributes
!
OCC-StdLite.Description: Lite Document Version 1.0
OCC-StdLite.FileExtension: stdl
OCC-StdLite.RetrievalPlugin: bd696001-5b34-11d1-b5ba-00a0c9064368
!
! BinLOcaf format
!

98
src/Storage/Storage_HeaderData.cxx
View File

@ -13,9 +13,11 @@
// commercial license or contractual agreement.
#include <Standard_Type.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Storage_HeaderData.hxx>
#include <Storage_Schema.hxx>
#include <Storage_BaseDriver.hxx>
#include <Storage_StreamTypeMismatchError.hxx>
#include <Storage_StreamExtCharParityError.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
@ -25,6 +27,98 @@ Storage_HeaderData::Storage_HeaderData() : myNBObj(0), myErrorStatus(Storage_VSO
{
}
Standard_Boolean Storage_HeaderData::Read (Storage_BaseDriver& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
return Standard_False;
}
// Read info section
myErrorStatus = theDriver.BeginReadInfoSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadInfoSection";
return Standard_False;
}
{
try
{
OCC_CATCH_SIGNALS
theDriver.ReadInfo (myNBObj,
myStorageVersion,
myDate,
mySchemaName,
mySchemaVersion,
myApplicationName,
myApplicationVersion,
myDataType,
myUserInfo);
}
catch (Storage_StreamTypeMismatchError)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadInfo";
return Standard_False;
}
catch (Storage_StreamExtCharParityError)
{
myErrorStatus = Storage_VSExtCharParityError;
myErrorStatusExt = "ReadInfo";
return Standard_False;
}
}
myErrorStatus = theDriver.EndReadInfoSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadInfoSection";
return Standard_False;
}
// Read comment section
myErrorStatus = theDriver.BeginReadCommentSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadCommentSection";
return Standard_False;
}
{
try
{
OCC_CATCH_SIGNALS
theDriver.ReadComment (myComments);
}
catch (Storage_StreamTypeMismatchError)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadComment";
return Standard_False;
}
catch (Storage_StreamExtCharParityError)
{
myErrorStatus = Storage_VSExtCharParityError;
myErrorStatusExt = "ReadComment";
return Standard_False;
}
}
myErrorStatus = theDriver.EndReadCommentSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadCommentSection";
return Standard_False;
}
return Standard_True;
}
TCollection_AsciiString Storage_HeaderData::CreationDate() const
{
return myDate;

3
src/Storage/Storage_HeaderData.hxx
View File

@ -28,6 +28,7 @@
#include <Storage_Error.hxx>
#include <MMgt_TShared.hxx>
class Storage_Schema;
class Storage_BaseDriver;
class TCollection_AsciiString;
class TCollection_ExtendedString;
@ -44,6 +45,8 @@ public:
Standard_EXPORT Storage_HeaderData();
Standard_EXPORT Standard_Boolean Read (Storage_BaseDriver& theDriver);
//! return the creation date
Standard_EXPORT TCollection_AsciiString CreationDate() const;

34
src/Storage/Storage_Root.cxx
View File

@ -21,23 +21,27 @@
IMPLEMENT_STANDARD_RTTIEXT(Storage_Root,MMgt_TShared)
Storage_Root::Storage_Root() : myRef(0)
{
}
Storage_Root::Storage_Root()
: myRef (0) {}
Storage_Root::Storage_Root(const TCollection_AsciiString& aName,const Handle(Standard_Persistent)& anObject) : myRef(0)
{
myName = aName;
myObject = anObject;
Storage_Root::Storage_Root (const TCollection_AsciiString& theName,
const Handle(Standard_Persistent)& theObject)
: myName (theName)
, myObject (theObject)
, myRef (0)
{}
if (!anObject.IsNull()) {
myType = anObject->DynamicType()->Name();
}
}
Storage_Root::Storage_Root (const TCollection_AsciiString& theName,
const Standard_Integer theRef,
const TCollection_AsciiString& theType)
: myName (theName)
, myType (theType)
, myRef (theRef)
{}
void Storage_Root::SetName(const TCollection_AsciiString& aName)
void Storage_Root::SetName (const TCollection_AsciiString& theName)
{
myName = aName;
myName = theName;
}
TCollection_AsciiString Storage_Root::Name() const
@ -48,10 +52,6 @@ TCollection_AsciiString Storage_Root::Name() const
void Storage_Root::SetObject(const Handle(Standard_Persistent)& anObject)
{
myObject = anObject;
if (!anObject.IsNull()) {
myType = anObject->DynamicType()->Name();
}
}
Handle(Standard_Persistent) Storage_Root::Object() const

9
src/Storage/Storage_Root.hxx
View File

@ -53,9 +53,14 @@ public:
Standard_EXPORT Storage_Root();
Standard_EXPORT Storage_Root(const TCollection_AsciiString& aName, const Handle(Standard_Persistent)& anObject);
Standard_EXPORT Storage_Root (const TCollection_AsciiString& theName,
const Handle(Standard_Persistent)& theObject);
Standard_EXPORT void SetName (const TCollection_AsciiString& aName);
Standard_EXPORT Storage_Root (const TCollection_AsciiString& theName,
const Standard_Integer theRef,
const TCollection_AsciiString& theType);
Standard_EXPORT void SetName (const TCollection_AsciiString& theName);
//! Returns the name of this root object.

62
src/Storage/Storage_RootData.cxx
View File

@ -13,13 +13,14 @@
// commercial license or contractual agreement.
#include <Standard_NoSuchObject.hxx>
#include <Standard_Persistent.hxx>
#include <Standard_Type.hxx>
#include <Storage_DataMapIteratorOfMapOfPers.hxx>
#include <Storage_Root.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Storage_RootData.hxx>
#include <Storage_Schema.hxx>
#include <Storage_Root.hxx>
#include <Storage_BaseDriver.hxx>
#include <Storage_StreamTypeMismatchError.hxx>
#include <Storage_DataMapIteratorOfMapOfPers.hxx>
#include <TCollection_AsciiString.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Storage_RootData,MMgt_TShared)
@ -28,6 +29,57 @@ Storage_RootData::Storage_RootData() : myErrorStatus(Storage_VSOk)
{
}
Standard_Boolean Storage_RootData::Read (Storage_BaseDriver& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
return Standard_False;
}
// Read root section
myErrorStatus = theDriver.BeginReadRootSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadRootSection";
return Standard_False;
}
TCollection_AsciiString aRootName, aTypeName;
Standard_Integer aRef;
Standard_Integer len = theDriver.RootSectionSize();
for (Standard_Integer i = 1; i <= len; i++)
{
try
{
OCC_CATCH_SIGNALS
theDriver.ReadRoot (aRootName, aRef, aTypeName);
}
catch (Storage_StreamTypeMismatchError)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadRoot";
return Standard_False;
}
Handle(Storage_Root) aRoot = new Storage_Root (aRootName, aRef, aTypeName);
myObjects.Bind (aRootName, aRoot);
}
myErrorStatus = theDriver.EndReadRootSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadRootSection";
return Standard_False;
}
return Standard_True;
}
Standard_Integer Storage_RootData::NumberOfRoots() const
{
return myObjects.Extent();

3
src/Storage/Storage_RootData.hxx
View File

@ -29,6 +29,7 @@
#include <Standard_Boolean.hxx>
class Standard_NoSuchObject;
class Storage_Schema;
class Storage_BaseDriver;
class Storage_Root;
class TCollection_AsciiString;
class Standard_Persistent;
@ -46,6 +47,8 @@ public:
Standard_EXPORT Storage_RootData();
Standard_EXPORT Standard_Boolean Read (Storage_BaseDriver& theDriver);
//! returns the number of roots.
Standard_EXPORT Standard_Integer NumberOfRoots() const;

764
src/Storage/Storage_Schema.cxx
View File

@ -287,7 +287,6 @@ Storage_Schema::Storage_Schema()
Clear();
ResetDefaultCallBack();
myCallBackState = Standard_False;
myNestedState = Standard_False;
}
//=======================================================================
@ -365,11 +364,11 @@ void Storage_Schema::Write
}
for (posto = 1; posto <= plist->Length(); posto++) {
AddTypeSelection(plist->Value(posto)->Object());
// AddTypeSelection(plist->Value(posto)->Object());
}
for (posfrom = plist->Length() + 1; posfrom <= iData->myPtoA.Length(); posfrom++) {
AddTypeSelection(iData->myPtoA.Value(posfrom));
// AddTypeSelection(iData->myPtoA.Value(posfrom));
}
// ...and now we write
@ -442,7 +441,7 @@ void Storage_Schema::Write
errorContext = "WriteRoot";
for (i = 1; i <= plist->Length(); i++) {
f.WriteRoot(plist->Value(i)->Name(),i,plist->Value(i)->Type());
f.WriteRoot(plist->Value(i)->Name(),i,"PDocStd_Document");
}
errorContext = "EndWriteRootSection";
@ -499,378 +498,6 @@ void Storage_Schema::Write
Clear();
}
//=======================================================================
//function : Read
//purpose : ...and read a Storage file
//Arguments:
// s: driver to read
//=======================================================================
Handle(Storage_Data) Storage_Schema::Read(Storage_BaseDriver& f) const
{
Handle(Storage_Data) dData = new Storage_Data;
Storage_Error errorCode;
static Standard_Boolean result;
static Standard_Integer len;
static Standard_Integer i;
i = 0 ;
Handle(Standard_Persistent) per;
Handle(Storage_HArrayOfCallBack) theCallBack;
Handle(Storage_InternalData) iData = dData->InternalData();
Handle(Storage_TypeData) tData = dData->TypeData();
Handle(Storage_RootData) rData = dData->RootData();
Handle(Storage_HeaderData) hData = dData->HeaderData();
if ((f.OpenMode() == Storage_VSRead) || (f.OpenMode() == Storage_VSReadWrite)) {
Storage_Schema::ISetCurrentData(dData);
// IReadHeaderSection can set an error status
//
result = IReadHeaderSection(f,hData);
if (result) {
Handle(Storage_CallBack) accallBack;
Standard_Integer p;
TCollection_AsciiString typeName;
iData->myReadArray = new Storage_HPArray(1,dData->NumberOfObjects());
// IReadTypeSection can set an error status
//
result = IReadTypeSection(f,tData);
if (result) {
len = dData->NumberOfTypes();
theCallBack = new Storage_HArrayOfCallBack(1,len);
{
try {
OCC_CATCH_SIGNALS
for (i = 1; i <= len; i++) {
typeName = tData->Type(i);
p = tData->Type(typeName);
theCallBack->SetValue(p,CallBackSelection(typeName));
}
}
catch(Storage_StreamUnknownTypeError) {
result = Standard_False;
dData->SetErrorStatus(Storage_VSUnknownType);
dData->SetErrorStatusExtension(typeName);
}
}
}
else {
dData->SetErrorStatus(tData->ErrorStatus());
dData->SetErrorStatusExtension(tData->ErrorStatusExtension());
}
}
else {
dData->SetErrorStatus(hData->ErrorStatus());
dData->SetErrorStatusExtension(hData->ErrorStatusExtension());
}
if (result) {
result = IReadRootSection(f,rData);
dData->SetErrorStatus(rData->ErrorStatus());
if (!result) dData->SetErrorStatusExtension(rData->ErrorStatusExtension());
}
if (result) {
Standard_Integer otype, oref = 0;
errorCode = f.BeginReadRefSection();
if (errorCode == Storage_VSOk) {
{
try {
OCC_CATCH_SIGNALS
len = f.RefSectionSize();
for (i = 1; i <= len; i++) {
f.ReadReferenceType(oref,otype);
iData->myReadArray->ChangeValue(oref) = theCallBack->Value(otype)->New();
if (!iData->myReadArray->ChangeValue(oref).IsNull()) iData->myReadArray->ChangeValue(oref)->_typenum = otype;
}
}
catch(Storage_StreamTypeMismatchError) {
TCollection_AsciiString aOref = oref;
result = Standard_False;
dData->SetErrorStatus(Storage_VSTypeMismatch);
dData->SetErrorStatusExtension(aOref);
}
}
if (result) {
errorCode = f.EndReadRefSection();
result = (errorCode == Storage_VSOk);
dData->SetErrorStatus(errorCode);
if (!result) dData->SetErrorStatusExtension("EndReadRefSection");
}
}
else {
result = Standard_False;
dData->SetErrorStatus(errorCode);
dData->SetErrorStatusExtension("BeginReadRefSection");
}
}
if (result) {
errorCode = f.BeginReadDataSection();
result = (errorCode == Storage_VSOk);
dData->SetErrorStatus(errorCode);
if (!result) dData->SetErrorStatusExtension("BeginReadDataSection");
}
if (result) {
Handle(Storage_Schema) me = this;
Handle(Storage_CallBack) rcback;
{
try {
OCC_CATCH_SIGNALS
for (i = 1; i <= dData->NumberOfObjects(); i++) {
Handle(Standard_Persistent) pobj = iData->myReadArray->Value(i);
if (!pobj.IsNull()) {
rcback = theCallBack->Value(pobj->_typenum);
rcback->Read(pobj,f,me);
pobj->_typenum = 0;
}
}
}
catch(Storage_StreamTypeMismatchError) {
result = Standard_False;
dData->SetErrorStatus(Storage_VSTypeMismatch);
dData->SetErrorStatusExtension(i-1);
}
catch(Storage_StreamFormatError) {
result = Standard_False;
dData->SetErrorStatus(Storage_VSFormatError);
dData->SetErrorStatusExtension(i-1);
}
catch(Storage_StreamReadError) {
result = Standard_False;
dData->SetErrorStatus(Storage_VSFormatError);
dData->SetErrorStatusExtension(i-1);
}
}
if (result) {
Handle(Storage_HSeqOfRoot) rlist = rData->Roots();
Handle(Storage_Root) rroot;
for(i = 1; i <= dData->NumberOfRoots(); i++) {
rroot = rlist->Value(i);
rData->UpdateRoot(rroot->Name(),iData->myReadArray->Value(rroot->Reference()));
}
errorCode = f.EndReadDataSection();
result = (errorCode == Storage_VSOk);
dData->SetErrorStatus(errorCode);
if (!result) dData->SetErrorStatusExtension("EndReadDataSection");
}
}
}
else {
dData->SetErrorStatus(Storage_VSModeError);
dData->SetErrorStatusExtension("OpenMode");
}
iData->Clear();
Clear();
return dData;
}
//=======================================================================
//function : ReadHeaderSection
//purpose : read the header part of the stream
//Arguments:
// s: driver to read
//=======================================================================
Handle(Storage_HeaderData) Storage_Schema::ReadHeaderSection
(Storage_BaseDriver& s) const
{
Handle(Storage_HeaderData) result = new Storage_HeaderData;
if ((s.OpenMode() == Storage_VSRead) || (s.OpenMode() == Storage_VSReadWrite)) {
IReadHeaderSection(s,result);
}
else {
result->SetErrorStatus(Storage_VSModeError);
result->SetErrorStatusExtension("OpenMode");
}
return result;
}
//=======================================================================
//function : ReadTypeSection
//purpose : fill the TypeData with the names of the type used
// in a stream
//Arguments:
// s: driver to read
//=======================================================================
Handle(Storage_TypeData) Storage_Schema::ReadTypeSection
(Storage_BaseDriver& f) const
{
Handle(Storage_TypeData) result = new Storage_TypeData;
if ((f.OpenMode() == Storage_VSRead) || (f.OpenMode() == Storage_VSReadWrite)) {
IReadTypeSection(f,result);
}
else {
result->SetErrorStatus(Storage_VSModeError);
result->SetErrorStatusExtension("OpenMode");
}
return result;
}
//=======================================================================
//function : ReadRootSection
//purpose : read root part of the file
//Arguments:
// s: driver to read
//=======================================================================
Handle(Storage_RootData) Storage_Schema::ReadRootSection
(Storage_BaseDriver& f) const
{
Handle(Storage_RootData) result = new Storage_RootData;
if ((f.OpenMode() == Storage_VSRead) || (f.OpenMode() == Storage_VSReadWrite)) {
IReadRootSection(f,result);
}
else {
result->SetErrorStatus(Storage_VSModeError);
result->SetErrorStatusExtension("OpenMode");
}
return result;
}
//=======================================================================
//function : SchemaKnownTypes
//purpose : returns the known types of a schema
//=======================================================================
const TColStd_SequenceOfAsciiString& Storage_Schema::SchemaKnownTypes() const
{
static TColStd_SequenceOfAsciiString aSeq;
return aSeq;
}
//=======================================================================
//function : GetAllSchemaKnownTypes
//purpose : returns the all known types of a schema and their
// nested schemes.
//PTV : add get of all known type for inheritance of schemas
//=======================================================================
Handle(TColStd_HSequenceOfAsciiString) Storage_Schema::
GetAllSchemaKnownTypes() const
{
Handle(TColStd_HSequenceOfAsciiString) aSeqOfType = new TColStd_HSequenceOfAsciiString;
const TColStd_SequenceOfAsciiString& alocalTypeList = SchemaKnownTypes();
for (Standard_Integer k = 1; k <= alocalTypeList.Length(); k++)
aSeqOfType->Append(alocalTypeList.Value(k));
// get nested schemas
Handle(Storage_HArrayOfSchema) aNestedSchemas = NestedSchemas();
if (!aNestedSchemas.IsNull())
{
for (Standard_Integer i = aNestedSchemas->Lower(); i <= aNestedSchemas->Upper(); i++)
{
Handle(Storage_Schema) aSchema = aNestedSchemas->Value(i);
if (aSchema.IsNull())
continue;
Handle(TColStd_HSequenceOfAsciiString) typeList = aSchema->GetAllSchemaKnownTypes();
for (Standard_Integer j = 1; j <= typeList->Length(); j++)
aSeqOfType->Append(typeList->Value(j));
}
}
return aSeqOfType;
}
//=======================================================================
//function : HasUnknownType
//purpose : indicates whether the are types in the driver
// which are not known from the schema and for which
// no callbacks have been set. The unknown types can
// be read in <theUnknownTypes>.
//=======================================================================
Standard_Boolean Storage_Schema::HasUnknownType
(Storage_BaseDriver& f,
TColStd_SequenceOfAsciiString& theUnknownTypes) const
{
Standard_Boolean result = Standard_False;
Handle(TColStd_HSequenceOfAsciiString) typeList = GetAllSchemaKnownTypes();
Handle(Storage_TypeData) tData;
tData = ReadTypeSection(f);
result = (tData->ErrorStatus() != Storage_VSOk);
if (!result) {
Standard_Integer i;
TColStd_MapOfAsciiString names;
for (i = 1; i <= typeList->Length(); i++) {
names.Add(typeList->Value(i));
}
Handle(TColStd_HSequenceOfAsciiString) flist = tData->Types();
for (i = 1; i <= flist->Length(); i++) {
if (!names.Contains(flist->Value(i))) {
theUnknownTypes.Append(flist->Value(i));
result = Standard_True;
}
}
}
return result;
}
//=======================================================================
//function : SetNestedSchemas
//purpose :
//=======================================================================
void Storage_Schema::SetNestedSchemas
(const Handle(Storage_HArrayOfSchema)& theSchemas)
{
myArrayOfSchema = theSchemas;
}
//=======================================================================
//function : ClearNestedSchemas
//purpose :
//=======================================================================
void Storage_Schema::ClearNestedSchemas()
{
myArrayOfSchema.Nullify();
}
//=======================================================================
//function : NestedSchemas
//purpose :
//=======================================================================
Handle(Storage_HArrayOfSchema) Storage_Schema::NestedSchemas() const
{
return myArrayOfSchema;
}
//=======================================================================
//function : AddReadUnknownTypeCallBack
//purpose : add two functions to the callback list
@ -995,92 +622,6 @@ Handle(Storage_CallBack) Storage_Schema::DefaultCallBack() const
return myDefaultCallBack;
}
//=======================================================================
//function : ResolveUnknownType
//purpose :
//=======================================================================
Handle(Storage_CallBack) Storage_Schema::ResolveUnknownType
(const TCollection_AsciiString& aTypeName,
const Handle(Standard_Persistent)& p,
const Storage_SolveMode aMode) const
{
Handle(Storage_CallBack) theCallBack;
if (!myArrayOfSchema.IsNull()) {
Standard_Integer i;
Standard_Boolean IsNotFound = Standard_True;
Standard_Boolean AlreadyMatched;
for(i = myArrayOfSchema->Lower(); i <= myArrayOfSchema->Upper() && IsNotFound; i++) {
Handle(Storage_Schema) aSchema = myArrayOfSchema->Value(i);
if (!aSchema.IsNull()) {
AlreadyMatched = aSchema->SetNested();
if (!AlreadyMatched) {
if (aMode == Storage_WriteSolve || aMode == Storage_ReadSolve) {
theCallBack = aSchema->CallBackSelection(aTypeName);
}
else if (aMode == Storage_AddSolve) {
theCallBack = aSchema->AddTypeSelection(p);
}
aSchema->UnsetNested();
IsNotFound = theCallBack.IsNull();
}
}
}
}
if (!myNestedState && theCallBack.IsNull()) {
if (myCallBack.IsBound(aTypeName)) {
theCallBack = myCallBack.Find(aTypeName)->CallBack();
}
else if (myCallBackState == Standard_True) {
theCallBack = myDefaultCallBack;
}
else {
Clear();
Standard_SStream aMsg;
aMsg << "Unknown type " << aTypeName << " in schema ";
if (!myName.IsEmpty()) {
aMsg << myName;
}
Storage_StreamUnknownTypeError::Raise(aMsg);
}
}
return theCallBack;
}
//=======================================================================
//function : CallBackSelection
//purpose :
//=======================================================================
Handle(Storage_CallBack) Storage_Schema::CallBackSelection
(const TCollection_AsciiString&) const
{
Handle(Storage_CallBack) theCallBack;
return theCallBack;
}
//=======================================================================
//function : AddTypeSelection
//purpose :
//=======================================================================
Handle(Storage_CallBack) Storage_Schema::AddTypeSelection
(const Handle(Standard_Persistent)&) const
{
Handle(Storage_CallBack) theCallBack;
return theCallBack;
}
//=======================================================================
//function : BindType
//purpose :
@ -1120,29 +661,6 @@ Handle(Storage_CallBack) Storage_Schema::TypeBinding
return result;
}
//=======================================================================
//function : ReadPersistentReference
//purpose :
//=======================================================================
void Storage_Schema::ReadPersistentReference
(Handle(Standard_Persistent)& sp,
Storage_BaseDriver& f)
{
Standard_Integer ref;
f.GetReference(ref);
if (ref != 0) {
Handle(Storage_InternalData) iData = Storage_Schema::ICurrentData()->InternalData();
sp = iData->myReadArray->Value(ref);
}
else {
sp.Nullify();
}
}
//=======================================================================
//function : AddPersistent
//purpose :
@ -1208,126 +726,6 @@ void Storage_Schema::Clear() const
Storage_Schema::ICurrentData().Nullify();
}
//=======================================================================
//function : IReadHeaderSection
//purpose :
//=======================================================================
Standard_Boolean Storage_Schema::IReadHeaderSection
(Storage_BaseDriver& f,
const Handle(Storage_HeaderData)& iData) const
{
Standard_Boolean result = Standard_False;
Storage_Error errorCode;
TCollection_AsciiString uinfo,mStorageVersion,mDate,mSchemaName,mSchemaVersion,mApplicationVersion;
TCollection_ExtendedString mApplicationName,mDataType;
TColStd_SequenceOfAsciiString mUserInfo;
TColStd_SequenceOfExtendedString mComment;
Standard_Integer mNBObj;
errorCode = f.BeginReadInfoSection();
if (errorCode == Storage_VSOk) {
{
try {
OCC_CATCH_SIGNALS
f.ReadInfo(mNBObj,
mStorageVersion,
mDate,
mSchemaName,
mSchemaVersion,
mApplicationName,
mApplicationVersion,
mDataType,
mUserInfo);
}
catch(Storage_StreamTypeMismatchError) {
iData->SetErrorStatus(Storage_VSTypeMismatch);
iData->SetErrorStatusExtension("ReadInfo");
return Standard_False;
}
catch(Storage_StreamExtCharParityError) {
iData->SetErrorStatus(Storage_VSExtCharParityError);
iData->SetErrorStatusExtension("ReadInfo");
return Standard_False;
}
}
errorCode = f.EndReadInfoSection();
iData->SetErrorStatus(errorCode);
result = (errorCode == Storage_VSOk);
if (result) {
Standard_Integer i;
iData->SetNumberOfObjects(mNBObj);
iData->SetStorageVersion(mStorageVersion);
iData->SetCreationDate(mDate);
iData->SetSchemaName(mSchemaName);
iData->SetSchemaVersion(mSchemaVersion);
iData->SetApplicationName(mApplicationName);
iData->SetApplicationVersion(mApplicationVersion);
iData->SetDataType(mDataType);
for (i = 1; i <= mUserInfo.Length(); i++) {
iData->AddToUserInfo(mUserInfo.Value(i));
}
errorCode = f.BeginReadCommentSection();
if (errorCode == Storage_VSOk) {
{
{
try {
OCC_CATCH_SIGNALS
f.ReadComment(mComment);
}
catch(Storage_StreamTypeMismatchError) {
iData->SetErrorStatus(Storage_VSTypeMismatch);
iData->SetErrorStatusExtension("ReadComment");
return Standard_False;
}
catch(Storage_StreamExtCharParityError) {
iData->SetErrorStatus(Storage_VSExtCharParityError);
iData->SetErrorStatusExtension("ReadComment");
return Standard_False;
}
}
}
errorCode = f.EndReadCommentSection();
iData->SetErrorStatus(errorCode);
iData->SetErrorStatusExtension("EndReadCommentSection");
result = (errorCode == Storage_VSOk);
if (result) {
for (i = 1; i <= mComment.Length(); i++) {
iData->AddToComments(mComment.Value(i));
}
}
}
else {
result = Standard_False;
iData->SetErrorStatus(errorCode);
iData->SetErrorStatusExtension("BeginReadCommentSection");
}
}
else {
iData->SetErrorStatusExtension("EndReadInfoSection");
}
}
else {
iData->SetErrorStatus(errorCode);
iData->SetErrorStatusExtension("BeginReadInfoSection");
}
return result;
}
#ifdef DATATYPE_MIGRATION
//=======================================================================
// environment variable CSF_MIGRATION_TYPES should define full path of a file
@ -1392,124 +790,6 @@ Standard_Boolean Storage_Schema::CheckTypeMigration(
}
#endif
//=======================================================================
//function : IReadTypeSection
//purpose :
//=======================================================================
Standard_Boolean Storage_Schema::IReadTypeSection
(Storage_BaseDriver& f,
const Handle(Storage_TypeData)& tData) const
{
static Standard_Boolean result;
TCollection_AsciiString typeName;
Standard_Integer typeNum;
Storage_Error errorCode;
Standard_Integer len,i;
result = Standard_False;
errorCode = f.BeginReadTypeSection();
if (errorCode == Storage_VSOk) {
try {
OCC_CATCH_SIGNALS
len = f.TypeSectionSize();
for (i = 1; i <= len; i++) {
f.ReadTypeInformations(typeNum,typeName);
#ifdef DATATYPE_MIGRATION
TCollection_AsciiString newName;
if(CheckTypeMigration(typeName, newName)) {
#ifdef OCCT_DEBUG
cout << "CheckTypeMigration:OldType = " <<typeName << " Len = "<<typeName.Length()<<endl;
cout << "CheckTypeMigration:NewType = " <<newName << " Len = "<< newName.Length()<<endl;
#endif
typeName = newName;
}
#endif
tData->AddType(typeName,typeNum);
}
result = Standard_True;
}
catch(Storage_StreamTypeMismatchError) {
tData->SetErrorStatus(Storage_VSTypeMismatch);
tData->SetErrorStatusExtension("ReadTypeInformations");
return Standard_False;
}
if (result) {
errorCode = f.EndReadTypeSection();
result = (errorCode == Storage_VSOk);
tData->SetErrorStatus(errorCode);
if (!result) tData->SetErrorStatusExtension("EndReadTypeSection");
}
}
else {
tData->SetErrorStatus(errorCode);
tData->SetErrorStatusExtension("BeginReadTypeSection");
}
return result;
}
//=======================================================================
//function : IReadRootSection
//purpose :
//=======================================================================
Standard_Boolean Storage_Schema::IReadRootSection
(Storage_BaseDriver& f,
const Handle(Storage_RootData)& rData) const
{
static Standard_Boolean result;
Standard_Integer len,i,ref;
Storage_Error errorCode;
Handle(Standard_Persistent) p;
Handle(Storage_Root) aRoot;
result = Standard_False;
errorCode = f.BeginReadRootSection();
if (errorCode == Storage_VSOk) {
TCollection_AsciiString rootName,typeName;
try {
OCC_CATCH_SIGNALS
len = f.RootSectionSize();
for (i = 1; i <= len; i++) {
f.ReadRoot(rootName,ref,typeName);
aRoot = new Storage_Root(rootName,p);
aRoot->SetReference(ref);
aRoot->SetType(typeName);
rData->AddRoot(aRoot);
}
result = Standard_True;
}
catch(Storage_StreamTypeMismatchError) {
result = Standard_False;
rData->SetErrorStatus(Storage_VSTypeMismatch);
rData->SetErrorStatusExtension("ReadRoot");
}
if (result) {
errorCode = f.EndReadRootSection();
result = (errorCode == Storage_VSOk);
rData->SetErrorStatus(errorCode);
if (!result) rData->SetErrorStatusExtension("EndReadRootSection");
}
}
else {
rData->SetErrorStatus(errorCode);
rData->SetErrorStatusExtension("BeginReadRootSection");
}
return result;
}
//=======================================================================
//function : ISetCurrentData
//purpose :
@ -1562,41 +842,3 @@ TCollection_AsciiString Storage_Schema::ICreationDate()
TCollection_AsciiString t(nowstr);
return t;
}
//=======================================================================
//function : SetNested
//purpose :
//=======================================================================
Standard_Boolean Storage_Schema::SetNested()
{
Standard_Boolean result = myNestedState;
myNestedState = Standard_True;
return result;
}
//=======================================================================
//function : IsNested
//purpose :
//=======================================================================
Standard_Boolean Storage_Schema::IsNested() const
{
return myNestedState;
}
//=======================================================================
//function : UnsetNested
//purpose :
//=======================================================================
Standard_Boolean Storage_Schema::UnsetNested()
{
Standard_Boolean result = myNestedState;
myNestedState = Standard_False;
return result;
}

72
src/Storage/Storage_Schema.hxx
View File

@ -107,50 +107,6 @@ public:
//! to be stored together.
Standard_EXPORT void Write (Storage_BaseDriver& s, const Handle(Storage_Data)& aData) const;
//! Returns the data read from the container defined
//! by the driver s. The retrieval operation is
//! performed according to the data schema with
//! which this algorithm is working.
//! These data are aggregated in a Storage_Data
//! object which may be browsed in order to extract
//! the root objects from the container.
Standard_EXPORT Handle(Storage_Data) Read (Storage_BaseDriver& s) const;
//! read the header part of the stream
//! Arguments:
//! s: driver to read
Standard_EXPORT Handle(Storage_HeaderData) ReadHeaderSection (Storage_BaseDriver& s) const;
//! fill the TypeData with the names of the type used
//! in a stream
//! Arguments:
//! s: driver to read
Standard_EXPORT Handle(Storage_TypeData) ReadTypeSection (Storage_BaseDriver& s) const;
//! read root part of the file
//! Arguments:
//! s: driver to read
Standard_EXPORT Handle(Storage_RootData) ReadRootSection (Storage_BaseDriver& s) const;
//! returns the known types of a schema
Standard_EXPORT virtual const TColStd_SequenceOfAsciiString& SchemaKnownTypes() const;
//! indicates whether the are types in the driver
//! which are not known from the schema and for which
//! no callbacks have been set. The unknown types can
//! be read in <theUnknownTypes>.
Standard_EXPORT Standard_Boolean HasUnknownType (Storage_BaseDriver& aDriver, TColStd_SequenceOfAsciiString& theUnknownTypes) const;
//! returns the all known types of a schema and their
//! nested schemes.
Standard_EXPORT Handle(TColStd_HSequenceOfAsciiString) GetAllSchemaKnownTypes() const;
Standard_EXPORT void SetNestedSchemas (const Handle(Storage_HArrayOfSchema)& theSchemas);
Standard_EXPORT void ClearNestedSchemas();
Standard_EXPORT Handle(Storage_HArrayOfSchema) NestedSchemas() const;
//! return a current date string
Standard_EXPORT static TCollection_AsciiString ICreationDate();
@ -204,18 +160,10 @@ public:
//! UseDefaultCallBack() is set.
Standard_EXPORT Handle(Storage_CallBack) DefaultCallBack() const;
Standard_EXPORT virtual Handle(Storage_CallBack) CallBackSelection (const TCollection_AsciiString& tName) const;
Standard_EXPORT virtual Handle(Storage_CallBack) AddTypeSelection (const Handle(Standard_Persistent)& sp) const;
void WritePersistentObjectHeader (const Handle(Standard_Persistent)& sp, Storage_BaseDriver& s);
void ReadPersistentObjectHeader (Storage_BaseDriver& s);
void WritePersistentReference (const Handle(Standard_Persistent)& sp, Storage_BaseDriver& s);
Standard_EXPORT void ReadPersistentReference (Handle(Standard_Persistent)& sp, Storage_BaseDriver& s);
Standard_EXPORT Standard_Boolean AddPersistent (const Handle(Standard_Persistent)& sp, const Standard_CString tName) const;
Standard_EXPORT Standard_Boolean PersistentToAdd (const Handle(Standard_Persistent)& sp) const;
@ -227,11 +175,6 @@ public:
protected:
Standard_EXPORT Standard_Boolean IsNested() const;
Standard_EXPORT Handle(Storage_CallBack) ResolveUnknownType (const TCollection_AsciiString& aTypeName, const Handle(Standard_Persistent)& aPers, const Storage_SolveMode aMode) const;
Standard_Boolean HasTypeBinding (const TCollection_AsciiString& aTypeName) const;
Standard_EXPORT void BindType (const TCollection_AsciiString& aTypeName, const Handle(Storage_CallBack)& aCallBack) const;
@ -242,19 +185,8 @@ protected:
private:
Standard_EXPORT Standard_Boolean SetNested();
Standard_EXPORT Standard_Boolean UnsetNested();
Standard_EXPORT void Clear() const;
Standard_EXPORT Standard_Boolean IReadHeaderSection (Storage_BaseDriver& s, const Handle(Storage_HeaderData)& iData) const;
Standard_EXPORT Standard_Boolean IReadTypeSection (Storage_BaseDriver& s, const Handle(Storage_TypeData)& tData) const;
Standard_EXPORT Standard_Boolean IReadRootSection (Storage_BaseDriver& s, const Handle(Storage_RootData)& rData) const;
Standard_EXPORT static void ISetCurrentData (const Handle(Storage_Data)& dData);
Standard_EXPORT static Handle(Storage_Data)& ICurrentData();
@ -264,10 +196,6 @@ private:
Handle(Storage_CallBack) myDefaultCallBack;
TCollection_AsciiString myName;
TCollection_AsciiString myVersion;
Handle(Storage_HArrayOfSchema) myArrayOfSchema;
Standard_Boolean myNestedState;
};

7
src/Storage/Storage_Schema.lxx
View File

@ -22,13 +22,6 @@ inline void Storage_Schema::WritePersistentObjectHeader(const Handle(Standard_Pe
f.WritePersistentObjectHeader(sp->_refnum,sp->_typenum);
}
inline void Storage_Schema::ReadPersistentObjectHeader(Storage_BaseDriver& f)
{
Standard_Integer i,j;
f.ReadPersistentObjectHeader(i,j);
}
inline Standard_Boolean Storage_Schema::HasTypeBinding(const TCollection_AsciiString& aTypeName) const
{
return Storage_Schema::ICurrentData()->InternalData()->myTypeBinding.IsBound(aTypeName);

55
src/Storage/Storage_TypeData.cxx
View File

@ -13,10 +13,11 @@
// commercial license or contractual agreement.
#include <Standard_ErrorHandler.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_Type.hxx>
#include <Storage_Schema.hxx>
#include <Storage_TypeData.hxx>
#include <Storage_BaseDriver.hxx>
#include <Storage_StreamTypeMismatchError.hxx>
#include <TCollection_AsciiString.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Storage_TypeData,MMgt_TShared)
@ -25,6 +26,56 @@ Storage_TypeData::Storage_TypeData() : myErrorStatus(Storage_VSOk)
{
}
Standard_Boolean Storage_TypeData::Read (Storage_BaseDriver& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
return Standard_False;
}
// Read type section
myErrorStatus = theDriver.BeginReadTypeSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadTypeSection";
return Standard_False;
}
Standard_Integer aTypeNum;
TCollection_AsciiString aTypeName;
Standard_Integer len = theDriver.TypeSectionSize();
for (Standard_Integer i = 1; i <= len; i++)
{
try
{
OCC_CATCH_SIGNALS
theDriver.ReadTypeInformations (aTypeNum, aTypeName);
}
catch (Storage_StreamTypeMismatchError)
{
myErrorStatus = Storage_VSTypeMismatch;
myErrorStatusExt = "ReadTypeInformations";
return Standard_False;
}
myPt.Add (aTypeName, aTypeNum);
}
myErrorStatus = theDriver.EndReadTypeSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadTypeSection";
return Standard_False;
}
return Standard_True;
}
Standard_Integer Storage_TypeData::NumberOfTypes() const
{
return myPt.Extent();

21
src/Storage/Storage_TypeData.hxx
View File

@ -29,6 +29,7 @@
#include <TColStd_HSequenceOfAsciiString.hxx>
class Standard_NoSuchObject;
class Storage_Schema;
class Storage_BaseDriver;
class TCollection_AsciiString;
@ -44,8 +45,19 @@ public:
Standard_EXPORT Storage_TypeData();
Standard_EXPORT Standard_Boolean Read (Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Integer NumberOfTypes() const;
//! add a type to the list
Standard_EXPORT void AddType (const TCollection_AsciiString& aName, const Standard_Integer aTypeNum);
//! returns the name of the type with number <aTypeNum>
Standard_EXPORT TCollection_AsciiString Type (const Standard_Integer aTypeNum) const;
//! returns the name of the type with number <aTypeNum>
Standard_EXPORT Standard_Integer Type (const TCollection_AsciiString& aTypeName) const;
Standard_EXPORT Standard_Boolean IsType (const TCollection_AsciiString& aName) const;
Standard_EXPORT Handle(TColStd_HSequenceOfAsciiString) Types() const;
@ -58,15 +70,6 @@ public:
Standard_EXPORT void Clear();
//! add a type to the list
Standard_EXPORT void AddType (const TCollection_AsciiString& aName, const Standard_Integer aTypeNum);
//! returns the name of the type with number <aTypeNum>
Standard_EXPORT TCollection_AsciiString Type (const Standard_Integer aTypeNum) const;
//! returns the name of the type with number <aTypeNum>
Standard_EXPORT Standard_Integer Type (const TCollection_AsciiString& aTypeName) const;
friend class Storage_Schema;

3
src/TKShape/CMakeLists.txt Normal file
View File

@ -0,0 +1,3 @@
project(TKShape)
OCCT_INCLUDE_CMAKE_FILE (adm/cmake/occt_toolkit)

4
src/TKShape/EXTERNLIB Normal file
View File

@ -0,0 +1,4 @@
TKernel
TKG2d
TKMath
TKCDF

2
src/TKShape/FILES Normal file
View File

@ -0,0 +1,2 @@
PACKAGES
EXTERNLIB

1
src/TKShape/PACKAGES Normal file
View File

@ -0,0 +1 @@
ShapePersistent

3
src/TKStd/CMakeLists.txt Normal file
View File

@ -0,0 +1,3 @@
project(TKStd)
OCCT_INCLUDE_CMAKE_FILE (adm/cmake/occt_toolkit)

9
src/TKStd/EXTERNLIB Normal file
View File

@ -0,0 +1,9 @@
TKCDF
TKernel
TKCAF
TKShape
TKLCAF
TKStdL
TKG3d
TKMath
TKG2d

2
src/TKStd/FILES Normal file
View File

@ -0,0 +1,2 @@
PACKAGES
EXTERNLIB

2
src/TKStd/PACKAGES Normal file
View File

@ -0,0 +1,2 @@
StdDrivers
StdPersistent

3
src/TKStdL/CMakeLists.txt Normal file
View File

@ -0,0 +1,3 @@
project(TKStdL)
OCCT_INCLUDE_CMAKE_FILE (adm/cmake/occt_toolkit)

4
src/TKStdL/EXTERNLIB Normal file
View File

@ -0,0 +1,4 @@
TKCDF
TKernel
TKShape
TKLCAF

2
src/TKStdL/FILES Normal file
View File

@ -0,0 +1,2 @@
PACKAGES
EXTERNLIB

3
src/TKStdL/PACKAGES Normal file
View File

@ -0,0 +1,3 @@
StdLDrivers
StdLPersistent
StdObjMgt

19
src/XmlLDrivers/XmlLDrivers_DocumentRetrievalDriver.cxx
View File

@ -170,25 +170,6 @@ Handle(CDM_Document) XmlLDrivers_DocumentRetrievalDriver::CreateDocument()
return new TDocStd_Document(PCDM_RetrievalDriver::GetFormat());
}
//=======================================================================
//function : SchemaName
//purpose : pure virtual method definition
//=======================================================================
TCollection_ExtendedString XmlLDrivers_DocumentRetrievalDriver::SchemaName() const
{
TCollection_ExtendedString schemaname;
return schemaname;
}
//=======================================================================
//function : Make
//purpose : pure virtual method definition
//=======================================================================
void XmlLDrivers_DocumentRetrievalDriver::Make (const Handle(PCDM_Document)&,
const Handle(CDM_Document)&)
{
}
//=======================================================================
//function : Read
//purpose :

4
src/XmlLDrivers/XmlLDrivers_DocumentRetrievalDriver.hxx
View File

@ -47,10 +47,6 @@ public:
Standard_EXPORT XmlLDrivers_DocumentRetrievalDriver();
Standard_EXPORT virtual TCollection_ExtendedString SchemaName() const Standard_OVERRIDE;
Standard_EXPORT virtual void Make (const Handle(PCDM_Document)& PD, const Handle(CDM_Document)& TD) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(CDM_Document) CreateDocument() Standard_OVERRIDE;
Standard_EXPORT virtual void Read (const TCollection_ExtendedString& theFileName, const Handle(CDM_Document)& theNewDocument, const Handle(CDM_Application)& theApplication) Standard_OVERRIDE;