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

0031546: Application Framework - Memory leak (100 bytes) on Load / Close OCAF document

Browse Source 
Class Standard_BaseDriver is inherited from Standard_Transient, its descendants are updated accordingly.
Handle is used to manipulate objects of this class and its descendants (instead of references or raw pointers) to ensure automatic destruction.

Added test bugs caf bug31546

Related:
- Standard_OVERRIDE is added in declarations of virtual methods in descendants of Storage_BaseDriver
- Methods operator << and operator >> are removed in descendants of Storage_BaseDriver (they repeat the same methods inherited from the base class)
- Typedef PCDM_BaseDriverPointer is marked as deprecated
- Unused class DDI_Ostream is removed
- Private field Standard_Transient::count is renamed to myRefCount_ to avoid compiler warnings if the same name is used within the scope of a descendant class
- Output of meaningful error messages is restored in DRAW commands fsdread and fsdwrite
This commit is contained in:
abv 2020-05-04 22:25:03 +03:00 committed by bugmaster
parent dcc4e908c2
commit 39c8dc708f
54 changed files with 664 additions and 2475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
src/DDF/DDF_BasicCommands.cxx
View File

@ -55,9 +55,6 @@
#include <TDF_RelocationTable.hxx>
#include <TDF_Tool.hxx>
#include <DDF_IOStream.hxx>
//=======================================================================
//function : Children
//purpose : Returns a list of sub-label entries.
@ -167,66 +164,6 @@ static Standard_Integer DDF_ForgetAttribute(Draw_Interpretor& di,
return 0;
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// save/restore & Store/Retrieve commands
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//==========================================================
// ErrorMessage
//==========================================================
void ErrorMessage (const Storage_Error n)
{
std::cout << "Storage Error: " << std::flush;
switch (n) {
case Storage_VSOk:
std::cout << "no problem" << std::endl;
break;
case Storage_VSOpenError:
std::cout << "while opening the stream" << std::endl;
break;
case Storage_VSModeError:
std::cout << "the stream is opened with a wrong mode for operation " << std::endl;
break;
case Storage_VSCloseError:
std::cout << "while closing the stream" << std::endl;
break;
case Storage_VSAlreadyOpen:
std::cout << "stream is already opened" << std::endl;
break;
case Storage_VSNotOpen:
std::cout << "stream not opened" << std::endl;
break;
case Storage_VSSectionNotFound:
std::cout << "the section is not found" << std::endl;
break;
case Storage_VSWriteError:
std::cout << "error during writing" << std::endl;
break;
case Storage_VSFormatError:
std::cout << "wrong format error occured while reading" << std::endl;
break;
case Storage_VSUnknownType:
std::cout << "try to read an unknown type" << std::endl;
break;
case Storage_VSTypeMismatch:
std::cout << "try to read a wrong primitive type (read a char while expecting a real)" << std::endl;
break;
case Storage_VSInternalError:
std::cout << "internal error" << std::endl;
break;
case Storage_VSExtCharParityError: std::cout << "parity error" << std::endl;
break;
default:
std::cout << "unknown error code" << std::endl;
break;
}
}
//=======================================================================
//function : DDF_SetTagger
//purpose : SetTagger (DF, entry)

1367
src/DDF/DDF_IOStream.cxx
View File

File diff suppressed because it is too large Load Diff

228
src/DDF/DDF_IOStream.hxx
View File

@ -1,228 +0,0 @@
// Created on: 1997-08-22
// Created by: DAUTRY Philippe
// Copyright (c) 1997-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// This file has been written using FSD_File.hxx as template.
// This is a specific adaptation for Draw use (save & restore commands).
// It is not sure at all this code is portable on any other plateform than
// SUN OS. Don't use it anywhere else.
// Thanks for comprehension. (22 august 97)
#ifndef DDF_IOStream_HeaderFile
#define DDF_IOStream_HeaderFile
#include <stdio.h>
#include <Storage_BaseDriver.hxx>
#include <Storage_Error.hxx>
#include <Storage_OpenMode.hxx>
#include <Storage_Position.hxx>
class Storage_StreamTypeMismatchError;
class Storage_StreamFormatError;
class Storage_StreamWriteError;
class Storage_StreamExtCharParityError;
#include <TColStd_SequenceOfExtendedString.hxx>
class DDF_IOStream : public Storage_BaseDriver {
public:
// Methods PUBLIC
//
DDF_IOStream();
Storage_Error Open(const TCollection_AsciiString& aName,const Storage_OpenMode aMode) ;
Storage_Error Open(std::istream* anIStream) ;
Storage_Error Open(std::ostream* anOStream) ;
Standard_Boolean IsEnd() ;
Storage_Position Tell() { return -1; }
static Storage_Error IsGoodFileType(std::istream* anIStream) ;
Storage_Error BeginWriteInfoSection() ;
void WriteInfo(const Standard_Integer nbObj,const TCollection_AsciiString& dbVersion,const TCollection_AsciiString& date,const TCollection_AsciiString& schemaName,const TCollection_AsciiString& schemaVersion,const TCollection_ExtendedString& appName,const TCollection_AsciiString& appVersion,const TCollection_ExtendedString& objectType,const TColStd_SequenceOfAsciiString& userInfo) ;
Storage_Error EndWriteInfoSection() ;
Storage_Error BeginReadInfoSection() ;
void ReadInfo(Standard_Integer& nbObj,TCollection_AsciiString& dbVersion,TCollection_AsciiString& date,TCollection_AsciiString& schemaName,TCollection_AsciiString& schemaVersion,TCollection_ExtendedString& appName,TCollection_AsciiString& appVersion,TCollection_ExtendedString& objectType,TColStd_SequenceOfAsciiString& userInfo) ;
void ReadCompleteInfo (Standard_IStream& theIStream, Handle(Storage_Data)& theData);
Storage_Error EndReadInfoSection() ;
Storage_Error BeginWriteCommentSection() ;
void WriteComment(const TColStd_SequenceOfExtendedString& userComments) ;
Storage_Error EndWriteCommentSection() ;
Storage_Error BeginReadCommentSection() ;
void ReadComment(TColStd_SequenceOfExtendedString& userComments) ;
Storage_Error EndReadCommentSection() ;
Storage_Error BeginWriteTypeSection() ;
void SetTypeSectionSize(const Standard_Integer aSize) ;
void WriteTypeInformations(const Standard_Integer typeNum,const TCollection_AsciiString& typeName) ;
Storage_Error EndWriteTypeSection() ;
Storage_Error BeginReadTypeSection() ;
Standard_Integer TypeSectionSize() ;
void ReadTypeInformations(Standard_Integer& typeNum,TCollection_AsciiString& typeName) ;
Storage_Error EndReadTypeSection() ;
Storage_Error BeginWriteRootSection() ;
void SetRootSectionSize(const Standard_Integer aSize) ;
void WriteRoot(const TCollection_AsciiString& rootName,const Standard_Integer aRef,const TCollection_AsciiString& aType) ;
Storage_Error EndWriteRootSection() ;
Storage_Error BeginReadRootSection() ;
Standard_Integer RootSectionSize() ;
void ReadRoot(TCollection_AsciiString& rootName,Standard_Integer& aRef,TCollection_AsciiString& aType) ;
Storage_Error EndReadRootSection() ;
Storage_Error BeginWriteRefSection() ;
void SetRefSectionSize(const Standard_Integer aSize) ;
void WriteReferenceType(const Standard_Integer reference,const Standard_Integer typeNum) ;
Storage_Error EndWriteRefSection() ;
Storage_Error BeginReadRefSection() ;
Standard_Integer RefSectionSize() ;
void ReadReferenceType(Standard_Integer& reference,Standard_Integer& typeNum) ;
Storage_Error EndReadRefSection() ;
Storage_Error BeginWriteDataSection() ;
void WritePersistentObjectHeader(const Standard_Integer aRef,const Standard_Integer aType) ;
void BeginWritePersistentObjectData() ;
void BeginWriteObjectData() ;
void EndWriteObjectData() ;
void EndWritePersistentObjectData() ;
Storage_Error EndWriteDataSection() ;
Storage_Error BeginReadDataSection() ;
void ReadPersistentObjectHeader(Standard_Integer& aRef,Standard_Integer& aType) ;
void BeginReadPersistentObjectData() ;
void BeginReadObjectData() ;
void EndReadObjectData() ;
void EndReadPersistentObjectData() ;
Storage_Error EndReadDataSection() ;
void SkipObject() ;
Storage_BaseDriver& PutReference(const Standard_Integer aValue) ;
Storage_BaseDriver& PutCharacter(const Standard_Character aValue) ;
Storage_BaseDriver& operator <<(const Standard_Character aValue)
{
return PutCharacter(aValue);
}
Storage_BaseDriver& PutExtCharacter(const Standard_ExtCharacter aValue) ;
Storage_BaseDriver& operator <<(const Standard_ExtCharacter aValue)
{
return PutExtCharacter(aValue);
}
Storage_BaseDriver& PutInteger(const Standard_Integer aValue) ;
Storage_BaseDriver& operator <<(const Standard_Integer aValue)
{
return PutInteger(aValue);
}
Storage_BaseDriver& PutBoolean(const Standard_Boolean aValue) ;
Storage_BaseDriver& operator <<(const Standard_Boolean aValue)
{
return PutBoolean(aValue);
}
Storage_BaseDriver& PutReal(const Standard_Real aValue) ;
Storage_BaseDriver& operator <<(const Standard_Real aValue)
{
return PutReal(aValue);
}
Storage_BaseDriver& PutShortReal(const Standard_ShortReal aValue) ;
Storage_BaseDriver& operator <<(const Standard_ShortReal aValue)
{
return PutShortReal(aValue);
}
Storage_BaseDriver& GetReference(Standard_Integer& aValue) ;
Storage_BaseDriver& GetCharacter(Standard_Character& aValue) ;
Storage_BaseDriver& operator >>(Standard_Character& aValue)
{
return GetCharacter(aValue);
}
Storage_BaseDriver& GetExtCharacter(Standard_ExtCharacter& aValue) ;
Storage_BaseDriver& operator >>(Standard_ExtCharacter& aValue)
{
return GetExtCharacter(aValue);
}
Storage_BaseDriver& GetInteger(Standard_Integer& aValue) ;
Storage_BaseDriver& operator >>(Standard_Integer& aValue)
{
return GetInteger(aValue);
}
Storage_BaseDriver& GetBoolean(Standard_Boolean& aValue) ;
Storage_BaseDriver& operator >>(Standard_Boolean& aValue)
{
return GetBoolean(aValue);
}
Storage_BaseDriver& GetReal(Standard_Real& aValue) ;
Storage_BaseDriver& operator >>(Standard_Real& aValue)
{
return GetReal(aValue);
}
Storage_BaseDriver& GetShortReal(Standard_ShortReal& aValue) ;
Storage_BaseDriver& operator >>(Standard_ShortReal& aValue)
{
return GetShortReal(aValue);
}
Storage_Error Close() ;
void Destroy() ;
~DDF_IOStream()
{
Destroy();
}
protected:
// Methods PROTECTED
//
void ReadLine(TCollection_AsciiString& buffer) ;
void ReadWord(TCollection_AsciiString& buffer) ;
void ReadExtendedLine(TCollection_ExtendedString& buffer) ;
void WriteExtendedLine(const TCollection_ExtendedString& buffer) ;
void ReadChar(TCollection_AsciiString& buffer,const Standard_Integer rsize) ;
void ReadString(TCollection_AsciiString& buffer) ;
void FlushEndOfLine() ;
Storage_Error FindTag(const Standard_CString aTag) ;
// Fields PROTECTED
//
private:
// Methods PRIVATE
//
static Standard_CString MagicNumber() ;
// Fields PRIVATE
//
//FSD_FStream myStream;
std::istream* myIStream;
std::ostream* myOStream;
};
// other inline functions and methods (like "C++: function call" methods)
//
#endif

2
src/DDF/FILES
View File

@ -9,8 +9,6 @@ DDF_BrowserCommands.cxx
DDF_Data.cxx
DDF_Data.hxx
DDF_DataCommands.cxx
DDF_IOStream.cxx
DDF_IOStream.hxx
DDF_ListIteratorOfTransactionStack.hxx
DDF_Transaction.cxx
DDF_Transaction.hxx

72
src/DDocStd/DDocStd_ShapeSchemaCommands.cxx
View File

@ -30,6 +30,57 @@
#include <StdStorage_TypeData.hxx>
#include <ShapePersistent_TopoDS.hxx>
//==========================================================
// ErrorMessage
//==========================================================
static void DDocStd_StorageErrorMessage (Draw_Interpretor& theDI, const Storage_Error theStatus)
{
switch (theStatus) {
case Storage_VSOk:
break;
case Storage_VSOpenError:
theDI << "Storage error: failed to open the stream";
break;
case Storage_VSModeError:
theDI << "Storage error: the stream is opened with a wrong mode for operation ";
break;
case Storage_VSCloseError:
theDI << "Storage error: failed to closing the stream";
break;
case Storage_VSAlreadyOpen:
theDI << "Storage error: stream is already opened";
break;
case Storage_VSNotOpen:
theDI << "Storage error: stream not opened";
break;
case Storage_VSSectionNotFound:
theDI << "Storage error: the section is not found";
break;
case Storage_VSWriteError:
theDI << "Storage error: error during writing";
break;
case Storage_VSFormatError:
theDI << "Storage error: wrong format error occured while reading";
break;
case Storage_VSUnknownType:
theDI << "Storage error: try to read an unknown type";
break;
case Storage_VSTypeMismatch:
theDI << "Storage error: try to read a wrong primitive type (read a char while expecting a real)";
break;
case Storage_VSInternalError:
theDI << "Storage error: internal error";
break;
case Storage_VSExtCharParityError:
theDI << "Storage error: parity error";
break;
default:
theDI << "Storage error: unknown error code";
break;
}
}
//=======================================================================
//function : DDocStd_ShapeSchema_Write
//=======================================================================
@ -51,7 +102,7 @@ static Standard_Integer DDocStd_fsdwrite(Draw_Interpretor& theDI,
return 1;
}
NCollection_Handle<Storage_BaseDriver> aFileDriver(new FSD_File);
Handle(Storage_BaseDriver) aFileDriver(new FSD_File);
Standard_Boolean hasStorageDriver = Standard_False;
Standard_Integer iArgN = theArgNb - 1;
@ -76,8 +127,9 @@ static Standard_Integer DDocStd_fsdwrite(Draw_Interpretor& theDI,
Storage_Error aStatus = aFileDriver->Open(theArgs[iArgN], Storage_VSWrite);
if (aStatus != Storage_VSOk) {
theDI << "Error : couldn't open file '" << "' for writing (" << aStatus << ")\n";
return 1;
theDI << "Error: cannot open file '" << "' for writing (" << aStatus << ")\n";
DDocStd_StorageErrorMessage (theDI, aStatus);
return 0;
}
TopTools_SequenceOfShape aShapes;
@ -129,15 +181,9 @@ static Standard_Integer DDocStd_fsdwrite(Draw_Interpretor& theDI,
aData->RootData()->AddRoot(aRoot);
}
Storage_Error anError = StdStorage::Write(*aFileDriver, aData);
Storage_Error anError = StdStorage::Write(aFileDriver, aData);
aFileDriver->Close();
if (anError != Storage_VSOk)
{
theDI << "Error : " << anError << "\n";
return 1;
}
DDocStd_StorageErrorMessage(theDI, anError);
return 0;
}
@ -170,8 +216,8 @@ static Standard_Integer DDocStd_fsdread(Draw_Interpretor& theDI,
Storage_Error anError = StdStorage::Read(TCollection_AsciiString(theArgs[1]), aData);
if (anError != Storage_VSOk)
{
theDI << "Error : " << anError << "\n";
return 1;
DDocStd_StorageErrorMessage(theDI, anError);
return 0;
}
TopTools_SequenceOfShape aShapes;

2
src/FSD/FSD_BinaryFile.cxx
View File

@ -32,6 +32,8 @@
const Standard_CString MAGICNUMBER = "BINFILE";
IMPLEMENT_STANDARD_RTTIEXT(FSD_BinaryFile,Storage_BaseDriver)
//=======================================================================
//function : FSD_BinaryFile
//purpose :

252
src/FSD/FSD_BinaryFile.hxx
View File

@ -17,10 +17,6 @@
#ifndef _FSD_BinaryFile_HeaderFile
#define _FSD_BinaryFile_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <FSD_BStream.hxx>
#include <FSD_FileHeader.hxx>
#include <Storage_BaseDriver.hxx>
@ -32,22 +28,15 @@
#include <Standard_Integer.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
#include <Standard_Character.hxx>
#include <Standard_ExtCharacter.hxx>
#include <Standard_Real.hxx>
#include <Standard_ShortReal.hxx>
#include <Standard_CString.hxx>
#include <Standard_Size.hxx>
class Storage_StreamTypeMismatchError;
class Storage_StreamFormatError;
class Storage_StreamWriteError;
class Storage_StreamExtCharParityError;
class TCollection_AsciiString;
class TCollection_ExtendedString;
class Storage_BaseDriver;
class Storage_HeaderData;
// Macro that tells if bytes must be reversed when read/write
// data to/from a binary file. It is needed to provide binary file compatibility
// between little and big endian platforms.
@ -60,26 +49,27 @@ class Storage_HeaderData;
#endif
#endif
DEFINE_STANDARD_HANDLE(FSD_BinaryFile,Storage_BaseDriver)
class FSD_BinaryFile : public Storage_BaseDriver
{
public:
DEFINE_STANDARD_RTTIEXT(FSD_BinaryFile,Storage_BaseDriver)
DEFINE_STANDARD_ALLOC
public:
Standard_EXPORT FSD_BinaryFile();
Standard_EXPORT Storage_Error Open (const TCollection_AsciiString& aName, const Storage_OpenMode aMode);
Standard_EXPORT Storage_Error Open (const TCollection_AsciiString& aName, const Storage_OpenMode aMode) Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsEnd();
Standard_EXPORT Standard_Boolean IsEnd() Standard_OVERRIDE;
//! return position in the file. Return -1 upon error.
Standard_EXPORT Storage_Position Tell();
Standard_EXPORT Storage_Position Tell() Standard_OVERRIDE;
Standard_EXPORT static Storage_Error IsGoodFileType (const TCollection_AsciiString& aName);
Standard_EXPORT Storage_Error BeginWriteInfoSection();
Standard_EXPORT Storage_Error BeginWriteInfoSection() Standard_OVERRIDE;
Standard_EXPORT static Standard_Integer WriteInfo (Standard_OStream& theOStream,
const Standard_Integer nbObj,
@ -93,223 +83,206 @@ public:
const TColStd_SequenceOfAsciiString& userInfo,
const Standard_Boolean theOnlyCount = Standard_False);
Standard_EXPORT void WriteInfo (const Standard_Integer nbObj, const TCollection_AsciiString& dbVersion, const TCollection_AsciiString& date, const TCollection_AsciiString& schemaName, const TCollection_AsciiString& schemaVersion, const TCollection_ExtendedString& appName, const TCollection_AsciiString& appVersion, const TCollection_ExtendedString& objectType, const TColStd_SequenceOfAsciiString& userInfo);
Standard_EXPORT void WriteInfo (const Standard_Integer nbObj,
const TCollection_AsciiString& dbVersion,
const TCollection_AsciiString& date,
const TCollection_AsciiString& schemaName,
const TCollection_AsciiString& schemaVersion,
const TCollection_ExtendedString& appName,
const TCollection_AsciiString& appVersion,
const TCollection_ExtendedString& objectType,
const TColStd_SequenceOfAsciiString& userInfo) Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndWriteInfoSection();
Standard_EXPORT Storage_Error EndWriteInfoSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndWriteInfoSection(Standard_OStream& theOStream);
Standard_EXPORT Storage_Error BeginReadInfoSection();
Standard_EXPORT Storage_Error BeginReadInfoSection() Standard_OVERRIDE;
Standard_EXPORT void ReadInfo (Standard_Integer& nbObj, TCollection_AsciiString& dbVersion, TCollection_AsciiString& date, TCollection_AsciiString& schemaName, TCollection_AsciiString& schemaVersion, TCollection_ExtendedString& appName, TCollection_AsciiString& appVersion, TCollection_ExtendedString& objectType, TColStd_SequenceOfAsciiString& userInfo);
Standard_EXPORT void ReadInfo (Standard_Integer& nbObj,
TCollection_AsciiString& dbVersion,
TCollection_AsciiString& date,
TCollection_AsciiString& schemaName,
TCollection_AsciiString& schemaVersion,
TCollection_ExtendedString& appName,
TCollection_AsciiString& appVersion,
TCollection_ExtendedString& objectType,
TColStd_SequenceOfAsciiString& userInfo) Standard_OVERRIDE;
Standard_EXPORT void ReadCompleteInfo (Standard_IStream& theIStream, Handle(Storage_Data)& theData);
Standard_EXPORT void ReadCompleteInfo (Standard_IStream& theIStream, Handle(Storage_Data)& theData) Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndReadInfoSection();
Standard_EXPORT Storage_Error EndReadInfoSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginWriteCommentSection();
Standard_EXPORT Storage_Error BeginWriteCommentSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginWriteCommentSection (Standard_OStream& theOStream);
Standard_EXPORT void WriteComment (const TColStd_SequenceOfExtendedString& userComments);
Standard_EXPORT void WriteComment (const TColStd_SequenceOfExtendedString& userComments) Standard_OVERRIDE;
Standard_EXPORT static Standard_Integer WriteComment (Standard_OStream& theOStream,
const TColStd_SequenceOfExtendedString& theComments,
const Standard_Boolean theOnlyCount = Standard_False);
Standard_EXPORT Storage_Error EndWriteCommentSection();
Standard_EXPORT Storage_Error EndWriteCommentSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndWriteCommentSection (Standard_OStream& theOStream);
Standard_EXPORT Storage_Error BeginReadCommentSection();
Standard_EXPORT Storage_Error BeginReadCommentSection() Standard_OVERRIDE;
Standard_EXPORT void ReadComment (TColStd_SequenceOfExtendedString& userComments);
Standard_EXPORT void ReadComment (TColStd_SequenceOfExtendedString& userComments) Standard_OVERRIDE;
Standard_EXPORT static void ReadComment (Standard_IStream& theIStream, TColStd_SequenceOfExtendedString& userComments);
Standard_EXPORT Storage_Error EndReadCommentSection();
Standard_EXPORT Storage_Error EndReadCommentSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginWriteTypeSection();
Standard_EXPORT Storage_Error BeginWriteTypeSection() Standard_OVERRIDE;
Standard_EXPORT void SetTypeSectionSize (const Standard_Integer aSize);
Standard_EXPORT void SetTypeSectionSize (const Standard_Integer aSize) Standard_OVERRIDE;
Standard_EXPORT void WriteTypeInformations (const Standard_Integer typeNum, const TCollection_AsciiString& typeName);
Standard_EXPORT void WriteTypeInformations (const Standard_Integer typeNum, const TCollection_AsciiString& typeName) Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndWriteTypeSection();
Standard_EXPORT Storage_Error EndWriteTypeSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginReadTypeSection();
Standard_EXPORT Storage_Error BeginReadTypeSection() Standard_OVERRIDE;
Standard_EXPORT Standard_Integer TypeSectionSize();
Standard_EXPORT Standard_Integer TypeSectionSize() Standard_OVERRIDE;
Standard_EXPORT static Standard_Integer TypeSectionSize(Standard_IStream& theIStream);
Standard_EXPORT void ReadTypeInformations (Standard_Integer& typeNum, TCollection_AsciiString& typeName);
Standard_EXPORT void ReadTypeInformations (Standard_Integer& typeNum, TCollection_AsciiString& typeName) Standard_OVERRIDE;
Standard_EXPORT static void ReadTypeInformations (Standard_IStream& theIStream, Standard_Integer& typeNum, TCollection_AsciiString& typeName);
Standard_EXPORT static void ReadTypeInformations (Standard_IStream& theIStream,
Standard_Integer& typeNum,
TCollection_AsciiString& typeName);
Standard_EXPORT Storage_Error EndReadTypeSection();
Standard_EXPORT Storage_Error EndReadTypeSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginWriteRootSection();
Standard_EXPORT Storage_Error BeginWriteRootSection() Standard_OVERRIDE;
Standard_EXPORT void SetRootSectionSize (const Standard_Integer aSize);
Standard_EXPORT void SetRootSectionSize (const Standard_Integer aSize) Standard_OVERRIDE;
Standard_EXPORT void WriteRoot (const TCollection_AsciiString& rootName, const Standard_Integer aRef, const TCollection_AsciiString& aType);
Standard_EXPORT void WriteRoot (const TCollection_AsciiString& rootName,
const Standard_Integer aRef,
const TCollection_AsciiString& aType) Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndWriteRootSection();
Standard_EXPORT Storage_Error EndWriteRootSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginReadRootSection();
Standard_EXPORT Storage_Error BeginReadRootSection() Standard_OVERRIDE;
Standard_EXPORT Standard_Integer RootSectionSize();
Standard_EXPORT Standard_Integer RootSectionSize() Standard_OVERRIDE;
Standard_EXPORT static Standard_Integer RootSectionSize(Standard_IStream& theIStream);
Standard_EXPORT void ReadRoot (TCollection_AsciiString& rootName, Standard_Integer& aRef, TCollection_AsciiString& aType);
Standard_EXPORT void ReadRoot (TCollection_AsciiString& rootName,
Standard_Integer& aRef,
TCollection_AsciiString& aType) Standard_OVERRIDE;
Standard_EXPORT static void ReadRoot (Standard_IStream& theIStream, TCollection_AsciiString& rootName, Standard_Integer& aRef, TCollection_AsciiString& aType);
Standard_EXPORT static void ReadRoot (Standard_IStream& theIStream,
TCollection_AsciiString& rootName,
Standard_Integer& aRef,
TCollection_AsciiString& aType);
Standard_EXPORT Storage_Error EndReadRootSection();
Standard_EXPORT Storage_Error EndReadRootSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginWriteRefSection();
Standard_EXPORT Storage_Error BeginWriteRefSection() Standard_OVERRIDE;
Standard_EXPORT void SetRefSectionSize (const Standard_Integer aSize);
Standard_EXPORT void SetRefSectionSize (const Standard_Integer aSize) Standard_OVERRIDE;
Standard_EXPORT void WriteReferenceType (const Standard_Integer reference, const Standard_Integer typeNum);
Standard_EXPORT void WriteReferenceType (const Standard_Integer reference, const Standard_Integer typeNum) Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndWriteRefSection();
Standard_EXPORT Storage_Error EndWriteRefSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginReadRefSection();
Standard_EXPORT Storage_Error BeginReadRefSection() Standard_OVERRIDE;
Standard_EXPORT Standard_Integer RefSectionSize();
Standard_EXPORT Standard_Integer RefSectionSize() Standard_OVERRIDE;
Standard_EXPORT static Standard_Integer RefSectionSize(Standard_IStream& theIStream);
Standard_EXPORT void ReadReferenceType (Standard_Integer& reference, Standard_Integer& typeNum);
Standard_EXPORT void ReadReferenceType (Standard_Integer& reference, Standard_Integer& typeNum) Standard_OVERRIDE;
Standard_EXPORT static void ReadReferenceType (Standard_IStream& theIStream, Standard_Integer& reference, Standard_Integer& typeNum);
Standard_EXPORT static void ReadReferenceType (Standard_IStream& theIStream,
Standard_Integer& reference,
Standard_Integer& typeNum);
Standard_EXPORT Storage_Error EndReadRefSection();
Standard_EXPORT Storage_Error EndReadRefSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginWriteDataSection();
Standard_EXPORT Storage_Error BeginWriteDataSection() Standard_OVERRIDE;
Standard_EXPORT void WritePersistentObjectHeader (const Standard_Integer aRef, const Standard_Integer aType);
Standard_EXPORT void WritePersistentObjectHeader (const Standard_Integer aRef, const Standard_Integer aType) Standard_OVERRIDE;
Standard_EXPORT void BeginWritePersistentObjectData();
Standard_EXPORT void BeginWritePersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT void BeginWriteObjectData();
Standard_EXPORT void BeginWriteObjectData() Standard_OVERRIDE;
Standard_EXPORT void EndWriteObjectData();
Standard_EXPORT void EndWriteObjectData() Standard_OVERRIDE;
Standard_EXPORT void EndWritePersistentObjectData();
Standard_EXPORT void EndWritePersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndWriteDataSection();
Standard_EXPORT Storage_Error EndWriteDataSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginReadDataSection();
Standard_EXPORT Storage_Error BeginReadDataSection() Standard_OVERRIDE;
Standard_EXPORT void ReadPersistentObjectHeader (Standard_Integer& aRef, Standard_Integer& aType);
Standard_EXPORT void ReadPersistentObjectHeader (Standard_Integer& aRef, Standard_Integer& aType) Standard_OVERRIDE;
Standard_EXPORT void BeginReadPersistentObjectData();
Standard_EXPORT void BeginReadPersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT void BeginReadObjectData();
Standard_EXPORT void BeginReadObjectData() Standard_OVERRIDE;
Standard_EXPORT void EndReadObjectData();
Standard_EXPORT void EndReadObjectData() Standard_OVERRIDE;
Standard_EXPORT void EndReadPersistentObjectData();
Standard_EXPORT void EndReadPersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT Storage_Error EndReadDataSection();
Standard_EXPORT Storage_Error EndReadDataSection() Standard_OVERRIDE;
Standard_EXPORT void SkipObject();
Standard_EXPORT void SkipObject() Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& PutReference (const Standard_Integer aValue);
Standard_EXPORT Storage_BaseDriver& PutReference (const Standard_Integer aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& PutCharacter (const Standard_Character aValue);
Storage_BaseDriver& operator << (const Standard_Character aValue)
{
return PutCharacter(aValue);
}
Standard_EXPORT Storage_BaseDriver& PutCharacter (const Standard_Character aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& PutExtCharacter (const Standard_ExtCharacter aValue);
Storage_BaseDriver& operator << (const Standard_ExtCharacter aValue)
{
return PutExtCharacter(aValue);
}
Standard_EXPORT Storage_BaseDriver& PutExtCharacter (const Standard_ExtCharacter aValue) Standard_OVERRIDE;
Standard_EXPORT static Standard_Integer PutInteger (Standard_OStream& theOStream,
const Standard_Integer aValue,
const Standard_Boolean theOnlyCount = Standard_False);
Standard_EXPORT Storage_BaseDriver& PutInteger (const Standard_Integer aValue);
Storage_BaseDriver& operator << (const Standard_Integer aValue)
{
return PutInteger(aValue);
}
Standard_EXPORT Storage_BaseDriver& PutInteger (const Standard_Integer aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& PutBoolean (const Standard_Boolean aValue);
Storage_BaseDriver& operator << (const Standard_Boolean aValue)
{
return PutBoolean(aValue);
}
Standard_EXPORT Storage_BaseDriver& PutBoolean (const Standard_Boolean aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& PutReal (const Standard_Real aValue);
Storage_BaseDriver& operator << (const Standard_Real aValue)
{
return PutReal(aValue);
}
Standard_EXPORT Storage_BaseDriver& PutReal (const Standard_Real aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& PutShortReal (const Standard_ShortReal aValue);
Storage_BaseDriver& operator << (const Standard_ShortReal aValue)
{
return PutShortReal(aValue);
}
Standard_EXPORT Storage_BaseDriver& PutShortReal (const Standard_ShortReal aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& GetReference (Standard_Integer& aValue);
Standard_EXPORT Storage_BaseDriver& GetReference (Standard_Integer& aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& GetCharacter (Standard_Character& aValue);
Storage_BaseDriver& operator >> (Standard_Character& aValue)
{
return GetCharacter(aValue);
}
Standard_EXPORT Storage_BaseDriver& GetCharacter (Standard_Character& aValue) Standard_OVERRIDE;
Standard_EXPORT static void GetReference (Standard_IStream& theIStream, Standard_Integer& aValue);
Standard_EXPORT Storage_BaseDriver& GetExtCharacter (Standard_ExtCharacter& aValue);
Storage_BaseDriver& operator >> (Standard_ExtCharacter& aValue)
{
return GetExtCharacter(aValue);
}
Standard_EXPORT Storage_BaseDriver& GetExtCharacter (Standard_ExtCharacter& aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& GetInteger (Standard_Integer& aValue);
Storage_BaseDriver& operator >> (Standard_Integer& aValue)
{
return GetInteger(aValue);
}
Standard_EXPORT Storage_BaseDriver& GetInteger (Standard_Integer& aValue) Standard_OVERRIDE;
Standard_EXPORT static void GetInteger (Standard_IStream& theIStream, Standard_Integer& aValue);
Standard_EXPORT Storage_BaseDriver& GetBoolean (Standard_Boolean& aValue);
Storage_BaseDriver& operator >> (Standard_Boolean& aValue)
{
return GetBoolean(aValue);
}
Standard_EXPORT Storage_BaseDriver& GetBoolean (Standard_Boolean& aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& GetReal (Standard_Real& aValue);
Storage_BaseDriver& operator >> (Standard_Real& aValue)
{
return GetReal(aValue);
}
Standard_EXPORT Storage_BaseDriver& GetReal (Standard_Real& aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_BaseDriver& GetShortReal (Standard_ShortReal& aValue);
Storage_BaseDriver& operator >> (Standard_ShortReal& aValue)
{
return GetShortReal(aValue);
}
Standard_EXPORT Storage_BaseDriver& GetShortReal (Standard_ShortReal& aValue) Standard_OVERRIDE;
Standard_EXPORT Storage_Error Close();
Standard_EXPORT Storage_Error Close() Standard_OVERRIDE;
Standard_EXPORT void Destroy();
~FSD_BinaryFile()
{
Destroy();
}
~FSD_BinaryFile()
{
Destroy();
}
public:
//!@name Own methods
///Inverse bytes in integer value
static Standard_Integer InverseInt(const Standard_Integer theValue)
@ -353,7 +326,6 @@ Storage_BaseDriver& operator >> (Standard_ShortReal& aValue)
Standard_EXPORT static Standard_CString MagicNumber();
protected:
//! read <rsize> character from the current position.
Standard_EXPORT void ReadChar (TCollection_AsciiString& buffer, const Standard_Size rsize);

2
src/FSD/FSD_CmpFile.cxx
View File

@ -20,6 +20,8 @@
const Standard_CString MAGICNUMBER = "CMPFILE";
IMPLEMENT_STANDARD_RTTIEXT(FSD_CmpFile, FSD_File)
//=======================================================================
//function : FSD_CmpFile
//purpose :

48
src/FSD/FSD_CmpFile.hxx
View File

@ -21,49 +21,48 @@
#include <Storage_BaseDriver.hxx>
#include <Storage_Error.hxx>
#include <Storage_OpenMode.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_CString.hxx>
class TCollection_AsciiString;
class TCollection_ExtendedString;
class Storage_BaseDriver;
DEFINE_STANDARD_HANDLE(FSD_CmpFile,FSD_File)
class FSD_CmpFile : public FSD_File
{
public:
DEFINE_STANDARD_RTTIEXT(FSD_CmpFile,FSD_File)
DEFINE_STANDARD_ALLOC
public:
Standard_EXPORT FSD_CmpFile();
Standard_EXPORT Storage_Error Open(const TCollection_AsciiString& aName, const Storage_OpenMode aMode);
Standard_EXPORT Storage_Error Open(const TCollection_AsciiString& aName, const Storage_OpenMode aMode) Standard_OVERRIDE;
Standard_EXPORT static Storage_Error IsGoodFileType(const TCollection_AsciiString& aName);
Standard_EXPORT Storage_Error BeginWriteInfoSection();
Standard_EXPORT Storage_Error BeginWriteInfoSection() Standard_OVERRIDE;
Standard_EXPORT Storage_Error BeginReadInfoSection();
Standard_EXPORT Storage_Error BeginReadInfoSection() Standard_OVERRIDE;
Standard_EXPORT void WritePersistentObjectHeader(const Standard_Integer aRef, const Standard_Integer aType);
Standard_EXPORT void WritePersistentObjectHeader(const Standard_Integer aRef, const Standard_Integer aType) Standard_OVERRIDE;
Standard_EXPORT void BeginWritePersistentObjectData();
Standard_EXPORT void BeginWritePersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT void BeginWriteObjectData();
Standard_EXPORT void BeginWriteObjectData() Standard_OVERRIDE;
Standard_EXPORT void EndWriteObjectData();
Standard_EXPORT void EndWriteObjectData() Standard_OVERRIDE;
Standard_EXPORT void EndWritePersistentObjectData();
Standard_EXPORT void EndWritePersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT void ReadPersistentObjectHeader(Standard_Integer& aRef, Standard_Integer& aType);
Standard_EXPORT void ReadPersistentObjectHeader(Standard_Integer& aRef, Standard_Integer& aType) Standard_OVERRIDE;
Standard_EXPORT void BeginReadPersistentObjectData();
Standard_EXPORT void BeginReadPersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT void BeginReadObjectData();
Standard_EXPORT void BeginReadObjectData() Standard_OVERRIDE;
Standard_EXPORT void EndReadObjectData();
Standard_EXPORT void EndReadObjectData() Standard_OVERRIDE;
Standard_EXPORT void EndReadPersistentObjectData();
Standard_EXPORT void EndReadPersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT void Destroy();
~FSD_CmpFile()
@ -73,22 +72,19 @@ public:
Standard_EXPORT static Standard_CString MagicNumber();
protected:
//! read from the current position to the end of line.
Standard_EXPORT void ReadLine(TCollection_AsciiString& buffer);
Standard_EXPORT void ReadLine(TCollection_AsciiString& buffer) Standard_OVERRIDE;
//! read extended chars (unicode) from the current position to the end of line.
Standard_EXPORT void ReadExtendedLine(TCollection_ExtendedString& buffer);
Standard_EXPORT void ReadExtendedLine(TCollection_ExtendedString& buffer) Standard_OVERRIDE;
//! write from the current position to the end of line.
Standard_EXPORT void WriteExtendedLine(const TCollection_ExtendedString& buffer);
Standard_EXPORT void WriteExtendedLine(const TCollection_ExtendedString& buffer) Standard_OVERRIDE;
//! read from the first none space character position to the end of line.
Standard_EXPORT void ReadString(TCollection_AsciiString& buffer);
Standard_EXPORT void ReadString(TCollection_AsciiString& buffer) Standard_OVERRIDE;
};

2
src/FSD/FSD_File.cxx
View File

@ -30,6 +30,8 @@ const Standard_Integer SIZEOFNORMALEXTENDEDSECTION = 16;
#define USEOSDREAL 1
IMPLEMENT_STANDARD_RTTIEXT(FSD_File, Storage_BaseDriver)
//=======================================================================
//function : FSD_File
//purpose :

242
src/FSD/FSD_File.hxx
View File

@ -17,25 +17,9 @@
#ifndef _FSD_File_HeaderFile
#define _FSD_File_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <FSD_FStream.hxx>
#include <Storage_BaseDriver.hxx>
#include <Storage_Error.hxx>
#include <Storage_OpenMode.hxx>
#include <Standard_Boolean.hxx>
#include <Storage_Position.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
#include <Standard_Character.hxx>
#include <Standard_ExtCharacter.hxx>
#include <Standard_Real.hxx>
#include <Standard_ShortReal.hxx>
#include <Standard_Size.hxx>
#include <Standard_CString.hxx>
class Storage_StreamTypeMismatchError;
class Storage_StreamFormatError;
class Storage_StreamWriteError;
@ -44,17 +28,16 @@ class TCollection_AsciiString;
class TCollection_ExtendedString;
class Storage_BaseDriver;
DEFINE_STANDARD_HANDLE(FSD_File,Storage_BaseDriver)
//! A general driver which defines as a file, the
//! physical container for data to be stored or retrieved.
class FSD_File : public Storage_BaseDriver
{
public:
DEFINE_STANDARD_RTTIEXT(FSD_File,Storage_BaseDriver)
DEFINE_STANDARD_ALLOC
public:
//! Constructs a driver defining as a file, the physical
//! container for data to be stored or retrieved.
@ -68,203 +51,174 @@ public:
//! The function returns Storage_VSOk if the file
//! is opened correctly, or any other value of the
//! Storage_Error enumeration which specifies the problem encountered.
Standard_EXPORT virtual Storage_Error Open (const TCollection_AsciiString& aName, const Storage_OpenMode aMode);
Standard_EXPORT virtual Storage_Error Open (const TCollection_AsciiString& aName, const Storage_OpenMode aMode) Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Boolean IsEnd();
Standard_EXPORT virtual Standard_Boolean IsEnd() Standard_OVERRIDE;
//! return position in the file. Return -1 upon error.
Standard_EXPORT virtual Storage_Position Tell();
Standard_EXPORT virtual Storage_Position Tell() Standard_OVERRIDE;
Standard_EXPORT static Storage_Error IsGoodFileType (const TCollection_AsciiString& aName);
Standard_EXPORT virtual Storage_Error BeginWriteInfoSection();
Standard_EXPORT virtual Storage_Error BeginWriteInfoSection() Standard_OVERRIDE;
Standard_EXPORT virtual void WriteInfo (const Standard_Integer nbObj, const TCollection_AsciiString& dbVersion, const TCollection_AsciiString& date, const TCollection_AsciiString& schemaName, const TCollection_AsciiString& schemaVersion, const TCollection_ExtendedString& appName, const TCollection_AsciiString& appVersion, const TCollection_ExtendedString& objectType, const TColStd_SequenceOfAsciiString& userInfo);
Standard_EXPORT virtual void WriteInfo (const Standard_Integer nbObj,
const TCollection_AsciiString& dbVersion,
const TCollection_AsciiString& date,
const TCollection_AsciiString& schemaName,
const TCollection_AsciiString& schemaVersion,
const TCollection_ExtendedString& appName,
const TCollection_AsciiString& appVersion,
const TCollection_ExtendedString& objectType,
const TColStd_SequenceOfAsciiString& userInfo) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndWriteInfoSection();
Standard_EXPORT virtual Storage_Error EndWriteInfoSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginReadInfoSection();
Standard_EXPORT virtual Storage_Error BeginReadInfoSection() Standard_OVERRIDE;
Standard_EXPORT virtual void ReadInfo (Standard_Integer& nbObj, TCollection_AsciiString& dbVersion, TCollection_AsciiString& date, TCollection_AsciiString& schemaName, TCollection_AsciiString& schemaVersion, TCollection_ExtendedString& appName, TCollection_AsciiString& appVersion, TCollection_ExtendedString& objectType, TColStd_SequenceOfAsciiString& userInfo);
Standard_EXPORT virtual void ReadInfo (Standard_Integer& nbObj,
TCollection_AsciiString& dbVersion,
TCollection_AsciiString& date,
TCollection_AsciiString& schemaName,
TCollection_AsciiString& schemaVersion,
TCollection_ExtendedString& appName,
TCollection_AsciiString& appVersion,
TCollection_ExtendedString& objectType,
TColStd_SequenceOfAsciiString& userInfo) Standard_OVERRIDE;
Standard_EXPORT virtual void ReadCompleteInfo (Standard_IStream& theIStream, Handle(Storage_Data)& theData);
Standard_EXPORT virtual void ReadCompleteInfo (Standard_IStream& theIStream, Handle(Storage_Data)& theData) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndReadInfoSection();
Standard_EXPORT virtual Storage_Error EndReadInfoSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginWriteCommentSection();
Standard_EXPORT virtual Storage_Error BeginWriteCommentSection() Standard_OVERRIDE;
Standard_EXPORT virtual void WriteComment (const TColStd_SequenceOfExtendedString& userComments);
Standard_EXPORT virtual void WriteComment (const TColStd_SequenceOfExtendedString& userComments) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndWriteCommentSection();
Standard_EXPORT virtual Storage_Error EndWriteCommentSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginReadCommentSection();
Standard_EXPORT virtual Storage_Error BeginReadCommentSection() Standard_OVERRIDE;
Standard_EXPORT virtual void ReadComment (TColStd_SequenceOfExtendedString& userComments);
Standard_EXPORT virtual void ReadComment (TColStd_SequenceOfExtendedString& userComments) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndReadCommentSection();
Standard_EXPORT virtual Storage_Error EndReadCommentSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginWriteTypeSection();
Standard_EXPORT virtual Storage_Error BeginWriteTypeSection() Standard_OVERRIDE;
Standard_EXPORT virtual void SetTypeSectionSize (const Standard_Integer aSize);
Standard_EXPORT virtual void SetTypeSectionSize (const Standard_Integer aSize) Standard_OVERRIDE;
Standard_EXPORT virtual void WriteTypeInformations (const Standard_Integer typeNum, const TCollection_AsciiString& typeName);
Standard_EXPORT virtual void WriteTypeInformations (const Standard_Integer typeNum,
const TCollection_AsciiString& typeName) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndWriteTypeSection();
Standard_EXPORT virtual Storage_Error EndWriteTypeSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginReadTypeSection();
Standard_EXPORT virtual Storage_Error BeginReadTypeSection() Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Integer TypeSectionSize();
Standard_EXPORT virtual Standard_Integer TypeSectionSize() Standard_OVERRIDE;
Standard_EXPORT virtual void ReadTypeInformations (Standard_Integer& typeNum, TCollection_AsciiString& typeName);
Standard_EXPORT virtual void ReadTypeInformations (Standard_Integer& typeNum, TCollection_AsciiString& typeName) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndReadTypeSection();
Standard_EXPORT virtual Storage_Error EndReadTypeSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginWriteRootSection();
Standard_EXPORT virtual Storage_Error BeginWriteRootSection() Standard_OVERRIDE;
Standard_EXPORT virtual void SetRootSectionSize (const Standard_Integer aSize);
Standard_EXPORT virtual void SetRootSectionSize (const Standard_Integer aSize) Standard_OVERRIDE;
Standard_EXPORT virtual void WriteRoot (const TCollection_AsciiString& rootName, const Standard_Integer aRef, const TCollection_AsciiString& aType);
Standard_EXPORT virtual void WriteRoot (const TCollection_AsciiString& rootName,
const Standard_Integer aRef,
const TCollection_AsciiString& aType) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndWriteRootSection();
Standard_EXPORT virtual Storage_Error EndWriteRootSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginReadRootSection();
Standard_EXPORT virtual Storage_Error BeginReadRootSection() Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Integer RootSectionSize();
Standard_EXPORT virtual Standard_Integer RootSectionSize() Standard_OVERRIDE;
Standard_EXPORT virtual void ReadRoot (TCollection_AsciiString& rootName, Standard_Integer& aRef, TCollection_AsciiString& aType);
Standard_EXPORT virtual void ReadRoot (TCollection_AsciiString& rootName,
Standard_Integer& aRef,
TCollection_AsciiString& aType) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndReadRootSection();
Standard_EXPORT virtual Storage_Error EndReadRootSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginWriteRefSection();
Standard_EXPORT virtual Storage_Error BeginWriteRefSection() Standard_OVERRIDE;
Standard_EXPORT virtual void SetRefSectionSize (const Standard_Integer aSize);
Standard_EXPORT virtual void SetRefSectionSize (const Standard_Integer aSize) Standard_OVERRIDE;
Standard_EXPORT virtual void WriteReferenceType (const Standard_Integer reference, const Standard_Integer typeNum);
Standard_EXPORT virtual void WriteReferenceType (const Standard_Integer reference, const Standard_Integer typeNum) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndWriteRefSection();
Standard_EXPORT virtual Storage_Error EndWriteRefSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginReadRefSection();
Standard_EXPORT virtual Storage_Error BeginReadRefSection() Standard_OVERRIDE;
Standard_EXPORT virtual Standard_Integer RefSectionSize();
Standard_EXPORT virtual Standard_Integer RefSectionSize() Standard_OVERRIDE;
Standard_EXPORT virtual void ReadReferenceType (Standard_Integer& reference, Standard_Integer& typeNum);
Standard_EXPORT virtual void ReadReferenceType (Standard_Integer& reference, Standard_Integer& typeNum) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndReadRefSection();
Standard_EXPORT virtual Storage_Error EndReadRefSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginWriteDataSection();
Standard_EXPORT virtual Storage_Error BeginWriteDataSection() Standard_OVERRIDE;
Standard_EXPORT virtual void WritePersistentObjectHeader (const Standard_Integer aRef, const Standard_Integer aType);
Standard_EXPORT virtual void WritePersistentObjectHeader (const Standard_Integer aRef, const Standard_Integer aType) Standard_OVERRIDE;
Standard_EXPORT virtual void BeginWritePersistentObjectData();
Standard_EXPORT virtual void BeginWritePersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT virtual void BeginWriteObjectData();
Standard_EXPORT virtual void BeginWriteObjectData() Standard_OVERRIDE;
Standard_EXPORT virtual void EndWriteObjectData();
Standard_EXPORT virtual void EndWriteObjectData() Standard_OVERRIDE;
Standard_EXPORT virtual void EndWritePersistentObjectData();
Standard_EXPORT virtual void EndWritePersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndWriteDataSection();
Standard_EXPORT virtual Storage_Error EndWriteDataSection() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error BeginReadDataSection();
Standard_EXPORT virtual Storage_Error BeginReadDataSection() Standard_OVERRIDE;
Standard_EXPORT virtual void ReadPersistentObjectHeader (Standard_Integer& aRef, Standard_Integer& aType);
Standard_EXPORT virtual void ReadPersistentObjectHeader (Standard_Integer& aRef, Standard_Integer& aType) Standard_OVERRIDE;
Standard_EXPORT virtual void BeginReadPersistentObjectData();
Standard_EXPORT virtual void BeginReadPersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT virtual void BeginReadObjectData();
Standard_EXPORT virtual void BeginReadObjectData() Standard_OVERRIDE;
Standard_EXPORT virtual void EndReadObjectData();
Standard_EXPORT virtual void EndReadObjectData() Standard_OVERRIDE;
Standard_EXPORT virtual void EndReadPersistentObjectData();
Standard_EXPORT virtual void EndReadPersistentObjectData() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_Error EndReadDataSection();
Standard_EXPORT virtual Storage_Error EndReadDataSection() Standard_OVERRIDE;
Standard_EXPORT virtual void SkipObject();
Standard_EXPORT virtual void SkipObject() Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& PutReference (const Standard_Integer aValue);
Standard_EXPORT virtual Storage_BaseDriver& PutReference (const Standard_Integer aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& PutCharacter (const Standard_Character aValue);
Standard_EXPORT virtual Storage_BaseDriver& PutCharacter (const Standard_Character aValue) Standard_OVERRIDE;
Storage_BaseDriver& operator << (const Standard_Character aValue)
{
return PutCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutExtCharacter(const Standard_ExtCharacter aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& PutExtCharacter (const Standard_ExtCharacter aValue);
Storage_BaseDriver& operator << (const Standard_ExtCharacter aValue)
{
return PutExtCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutInteger (const Standard_Integer aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& PutInteger (const Standard_Integer aValue);
Storage_BaseDriver& operator << (const Standard_Integer aValue)
{
return PutInteger(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutBoolean (const Standard_Boolean aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& PutBoolean (const Standard_Boolean aValue);
Storage_BaseDriver& operator << (const Standard_Boolean aValue)
{
return PutBoolean(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutReal (const Standard_Real aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& PutReal (const Standard_Real aValue);
Storage_BaseDriver& operator << (const Standard_Real aValue)
{
return PutReal(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutShortReal (const Standard_ShortReal aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& PutShortReal (const Standard_ShortReal aValue);
Storage_BaseDriver& operator << (const Standard_ShortReal aValue)
{
return PutShortReal(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetReference (Standard_Integer& aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& GetReference (Standard_Integer& aValue);
Standard_EXPORT virtual Storage_BaseDriver& GetCharacter (Standard_Character& aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& GetCharacter (Standard_Character& aValue);
Storage_BaseDriver& operator >> (Standard_Character& aValue)
{
return GetCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetExtCharacter (Standard_ExtCharacter& aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& GetExtCharacter (Standard_ExtCharacter& aValue);
Storage_BaseDriver& operator >> (Standard_ExtCharacter& aValue)
{
return GetExtCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetInteger (Standard_Integer& aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& GetInteger (Standard_Integer& aValue);
Storage_BaseDriver& operator >> (Standard_Integer& aValue)
{
return GetInteger(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetBoolean (Standard_Boolean& aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& GetBoolean (Standard_Boolean& aValue);
Storage_BaseDriver& operator >> (Standard_Boolean& aValue)
{
return GetBoolean(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetReal (Standard_Real& aValue);
Storage_BaseDriver& operator >> (Standard_Real& aValue)
{
return GetReal(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetShortReal (Standard_ShortReal& aValue);
Storage_BaseDriver& operator >> (Standard_ShortReal& aValue)
{
return GetShortReal(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetReal (Standard_Real& aValue) Standard_OVERRIDE;
Standard_EXPORT virtual Storage_BaseDriver& GetShortReal (Standard_ShortReal& aValue) Standard_OVERRIDE;
//! Closes the file driven by this driver. This file was
//! opened by the last call to the function Open.
//! The function returns Storage_VSOk if the
//! closure is correctly done, or any other value of
//! the Storage_Error enumeration which specifies the problem encountered.
Standard_EXPORT virtual Storage_Error Close();
Standard_EXPORT virtual Storage_Error Close() Standard_OVERRIDE;
Standard_EXPORT void Destroy();
~FSD_File()
@ -274,9 +228,7 @@ public:
Standard_EXPORT static Standard_CString MagicNumber();
protected:
protected:
//! read from the current position to the end of line.
Standard_EXPORT virtual void ReadLine (TCollection_AsciiString& buffer);
@ -300,7 +252,7 @@ public:
Standard_EXPORT virtual Storage_Error FindTag (const Standard_CString aTag);
protected:
FSD_FStream myStream;
};

2
src/FSD/FSD_FileHeader.hxx
View File

@ -16,6 +16,8 @@
#ifndef _FSD_FileHeader_HeaderFile
#define _FSD_FileHeader_HeaderFile
#include <Standard_PrimitiveTypes.hxx>
struct FSD_FileHeader {
Standard_Integer testindian;
Standard_Integer binfo;

5
src/PCDM/PCDM.cxx
View File

@ -37,7 +37,8 @@
//purpose :
//=======================================================================
PCDM_TypeOfFileDriver PCDM::FileDriverType(const TCollection_AsciiString& aFileName, PCDM_BaseDriverPointer& aBaseDriver) {
PCDM_TypeOfFileDriver PCDM::FileDriverType(const TCollection_AsciiString& aFileName, Handle(Storage_BaseDriver)& aBaseDriver)
{
if(FSD_CmpFile::IsGoodFileType(aFileName) == Storage_VSOk) {
aBaseDriver=new FSD_CmpFile;
return PCDM_TOFD_CmpFile;
@ -61,7 +62,7 @@ PCDM_TypeOfFileDriver PCDM::FileDriverType(const TCollection_AsciiString& aFileN
//purpose :
//=======================================================================
PCDM_TypeOfFileDriver PCDM::FileDriverType (Standard_IStream& theIStream, PCDM_BaseDriverPointer& theBaseDriver)
PCDM_TypeOfFileDriver PCDM::FileDriverType (Standard_IStream& theIStream, Handle(Storage_BaseDriver)& theBaseDriver)
{
TCollection_AsciiString aReadMagicNumber;

17
src/PCDM/PCDM.hxx
View File

@ -17,26 +17,21 @@
#ifndef _PCDM_HeaderFile
#define _PCDM_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_IStream.hxx>
#include <Standard_Boolean.hxx>
#include <Storage_BaseDriver.hxx>
#include <PCDM_TypeOfFileDriver.hxx>
#include <PCDM_BaseDriverPointer.hxx>
class CDM_Document;
class PCDM_StorageDriver;
class TCollection_AsciiString;
class PCDM
{
public:
Standard_EXPORT static PCDM_TypeOfFileDriver FileDriverType (const TCollection_AsciiString& aFileName, PCDM_BaseDriverPointer& aBaseDriver);
Standard_EXPORT static PCDM_TypeOfFileDriver FileDriverType (const TCollection_AsciiString& aFileName,
Handle(Storage_BaseDriver)& aBaseDriver);
Standard_EXPORT static PCDM_TypeOfFileDriver FileDriverType (Standard_IStream& theIStream, PCDM_BaseDriverPointer& theBaseDriver);
Standard_EXPORT static PCDM_TypeOfFileDriver FileDriverType (Standard_IStream& theIStream,
Handle(Storage_BaseDriver)& theBaseDriver);
DEFINE_STANDARD_ALLOC
};

4
src/PCDM/PCDM_BaseDriverPointer.hxx
View File

@ -18,6 +18,8 @@
#define _PCDM_BaseDriverPointer_HeaderFile
class Storage_BaseDriver;
typedef Storage_BaseDriver* PCDM_BaseDriverPointer;
Standard_DEPRECATED("Typedef PCDM_BaseDriverPointer is kept for compatibility only, instead consider using Handle(Storage_BaseDriver) explicitly")
typedef Handle(Storage_BaseDriver) PCDM_BaseDriverPointer;
#endif // _PCDM_BaseDriverPointer_HeaderFile

20
src/PCDM/PCDM_ReadWriter.cxx
View File

@ -45,7 +45,7 @@ static TCollection_ExtendedString TryXmlDriverType (Standard_IStream& theIStream
//purpose :
//=======================================================================
void PCDM_ReadWriter::Open (Storage_BaseDriver& aDriver,
void PCDM_ReadWriter::Open (const Handle(Storage_BaseDriver)& aDriver,
const TCollection_ExtendedString& aFileName,
const Storage_OpenMode aMode)
{
@ -113,7 +113,7 @@ TCollection_ExtendedString PCDM_ReadWriter::FileFormat
{
TCollection_ExtendedString theFormat;
PCDM_BaseDriverPointer theFileDriver;
Handle(Storage_BaseDriver) theFileDriver;
// conversion to UTF-8 is done inside
TCollection_AsciiString theFileName (aFileName);
@ -126,10 +126,10 @@ TCollection_ExtendedString PCDM_ReadWriter::FileFormat
try {
OCC_CATCH_SIGNALS
Open(*theFileDriver,aFileName,Storage_VSRead);
Open(theFileDriver,aFileName,Storage_VSRead);
theFileIsOpen=Standard_True;
Storage_HeaderData hd;
hd.Read (*theFileDriver);
hd.Read (theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd.UserInfo();
Standard_Boolean found=Standard_False;
for (Standard_Integer i =1; !found && i<= refUserInfo.Length() ; i++) {
@ -142,16 +142,16 @@ TCollection_ExtendedString PCDM_ReadWriter::FileFormat
if (!found)
{
Storage_TypeData td;
td.Read (*theFileDriver);
td.Read (theFileDriver);
theFormat = td.Types()->Value(1);
}
}
catch (Standard_Failure const&) {}
if(theFileIsOpen)theFileDriver->Close();
delete theFileDriver;
if(theFileIsOpen)
{
theFileDriver->Close();
}
return theFormat;
}
@ -165,7 +165,7 @@ TCollection_ExtendedString PCDM_ReadWriter::FileFormat (Standard_IStream& theISt
{
TCollection_ExtendedString aFormat;
Storage_BaseDriver* aFileDriver = 0L;
Handle(Storage_BaseDriver) aFileDriver;
if (PCDM::FileDriverType (theIStream, aFileDriver) == PCDM_TOFD_XmlFile)
{
return ::TryXmlDriverType (theIStream);

4
src/PCDM/PCDM_ReadWriter.hxx
View File

@ -62,7 +62,9 @@ public:
Standard_EXPORT virtual Standard_Integer ReadDocumentVersion (const TCollection_ExtendedString& aFileName, const Handle(Message_Messenger)& theMsgDriver) const = 0;
Standard_EXPORT static void Open (Storage_BaseDriver& aDriver, const TCollection_ExtendedString& aFileName, const Storage_OpenMode anOpenMode);
Standard_EXPORT static void Open (const Handle(Storage_BaseDriver)& aDriver,
const TCollection_ExtendedString& aFileName,
const Storage_OpenMode anOpenMode);
//! returns the convenient Reader for a File.
Standard_EXPORT static Handle(PCDM_ReadWriter) Reader (const TCollection_ExtendedString& aFileName);

36
src/PCDM/PCDM_ReadWriter_1.cxx
View File

@ -230,7 +230,7 @@ Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_Exten
theReferencesCounter=0;
static Standard_Integer i ;
PCDM_BaseDriverPointer theFileDriver;
Handle(Storage_BaseDriver) theFileDriver;
TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
return theReferencesCounter;
@ -240,12 +240,12 @@ Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_Exten
try {
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
PCDM_ReadWriter::Open(theFileDriver,aFileName,Storage_VSRead);
theFileIsOpen=Standard_True;
Handle(Storage_Schema) s = new Storage_Schema;
Storage_HeaderData hd;
hd.Read (*theFileDriver);
hd.Read (theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd.UserInfo();
for ( i =1; i<= refUserInfo.Length() ; i++) {
@ -264,9 +264,11 @@ Standard_Integer PCDM_ReadWriter_1::ReadReferenceCounter(const TCollection_Exten
}
catch (Standard_Failure const&) {}
if(theFileIsOpen) theFileDriver->Close();
if(theFileIsOpen)
{
theFileDriver->Close();
}
delete theFileDriver;
return theReferencesCounter;
}
@ -338,18 +340,18 @@ void PCDM_ReadWriter_1::ReadUserInfo(const TCollection_ExtendedString& aFileName
const TCollection_AsciiString& Start,
const TCollection_AsciiString& End,
TColStd_SequenceOfExtendedString& theUserInfo,
const Handle(Message_Messenger)&) {
const Handle(Message_Messenger)&)
{
static Standard_Integer i ;
PCDM_BaseDriverPointer theFileDriver;
Handle(Storage_BaseDriver) theFileDriver;
TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
return;
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
PCDM_ReadWriter::Open(theFileDriver,aFileName,Storage_VSRead);
Handle(Storage_Schema) s = new Storage_Schema;
Storage_HeaderData hd;
hd.Read (*theFileDriver);
hd.Read (theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd.UserInfo();
Standard_Integer debut=0,fin=0;
@ -366,7 +368,6 @@ void PCDM_ReadWriter_1::ReadUserInfo(const TCollection_ExtendedString& aFileName
}
}
theFileDriver->Close();
delete theFileDriver;
}
//=======================================================================
@ -379,7 +380,7 @@ Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_Extend
static Standard_Integer theVersion ;
theVersion=-1;
PCDM_BaseDriverPointer theFileDriver;
Handle(Storage_BaseDriver) theFileDriver;
TCollection_AsciiString aFileNameU(aFileName);
if(PCDM::FileDriverType(aFileNameU, theFileDriver) == PCDM_TOFD_Unknown)
return theVersion;
@ -389,11 +390,11 @@ Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_Extend
try {
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open(*theFileDriver,aFileName,Storage_VSRead);
PCDM_ReadWriter::Open(theFileDriver,aFileName,Storage_VSRead);
theFileIsOpen=Standard_True;
Handle(Storage_Schema) s = new Storage_Schema;
Storage_HeaderData hd;
hd.Read (*theFileDriver);
hd.Read (theFileDriver);
const TColStd_SequenceOfAsciiString &refUserInfo = hd.UserInfo();
static Standard_Integer i ;
@ -414,7 +415,10 @@ Standard_Integer PCDM_ReadWriter_1::ReadDocumentVersion(const TCollection_Extend
catch (Standard_Failure const&) {}
if(theFileIsOpen) theFileDriver->Close();
delete theFileDriver;
if(theFileIsOpen)
{
theFileDriver->Close();
}
return theVersion;
}

4
src/PCDM/PCDM_StorageDriver.cxx
View File

@ -91,10 +91,10 @@ void PCDM_StorageDriver::Write(const Handle(CDM_Document)& aDocument, const TCol
theData->AddToComments(aComments(i));
}
FSD_CmpFile theFile;
Handle(FSD_CmpFile) theFile = new FSD_CmpFile;
PCDM_ReadWriter::Open(theFile,aFileName,Storage_VSWrite);
theSchema->Write(theFile,theData);
theFile.Close();
theFile->Close();
if ( theData->ErrorStatus() != Storage_VSOk )
throw PCDM_DriverError(theData->ErrorStatusExtension().ToCString());

4
src/Standard/Standard_Transient.cxx
View File

@ -75,11 +75,11 @@ Standard_Transient* Standard_Transient::This() const
// Increment reference counter
void Standard_Transient::IncrementRefCounter() const
{
Standard_Atomic_Increment (&count);
Standard_Atomic_Increment (&myRefCount_);
}
// Decrement reference counter
Standard_Integer Standard_Transient::DecrementRefCounter() const
{
return Standard_Atomic_Decrement (&count);
return Standard_Atomic_Decrement(&myRefCount_);
}

12
src/Standard/Standard_Transient.hxx
View File

@ -37,10 +37,10 @@ public:
public:
//! Empty constructor
Standard_Transient() : count(0) {}
Standard_Transient() : myRefCount_(0) {}
//! Copy constructor -- does nothing
Standard_Transient (const Standard_Transient&) : count(0) {}
Standard_Transient (const Standard_Transient&) : myRefCount_(0) {}
//! Assignment operator, needed to avoid copying reference counter
Standard_Transient& operator= (const Standard_Transient&) { return *this; }
@ -90,7 +90,7 @@ public:
//!@name Reference counting, for use by handle<>
//! Get the reference counter of this object
Standard_Integer GetRefCount() const { return count; }
Standard_Integer GetRefCount() const { return myRefCount_; }
//! Increments the reference counter of this object
Standard_EXPORT void IncrementRefCounter() const;
@ -101,8 +101,10 @@ public:
private:
//! Reference counter
mutable volatile Standard_Integer count;
//! Reference counter.
//! Note use of underscore, aimed to reduce probability
//! of conflict with names of members of derived classes.
mutable volatile Standard_Integer myRefCount_;
};

16
src/StdLDrivers/StdLDrivers_DocumentRetrievalDriver.cxx
View File

@ -79,20 +79,18 @@ Handle(StdObjMgt_Persistent) StdLDrivers_DocumentRetrievalDriver::read (
Standard_Integer i;
// Create a driver appropriate for the given file
PCDM_BaseDriverPointer aFileDriverPtr;
if (PCDM::FileDriverType (TCollection_AsciiString (theFileName), aFileDriverPtr) == PCDM_TOFD_Unknown)
Handle(Storage_BaseDriver) aFileDriver;
if (PCDM::FileDriverType (TCollection_AsciiString (theFileName), aFileDriver) == PCDM_TOFD_Unknown)
{
myReaderStatus = PCDM_RS_UnknownFileDriver;
return NULL;
}
NCollection_Handle<Storage_BaseDriver> aFileDriver (aFileDriverPtr);
// Try to open the file
try
{
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open (*aFileDriver, theFileName, Storage_VSRead);
PCDM_ReadWriter::Open (aFileDriver, theFileName, Storage_VSRead);
myReaderStatus = PCDM_RS_OK;
}
catch (Standard_Failure const& anException)
@ -105,17 +103,17 @@ Handle(StdObjMgt_Persistent) StdLDrivers_DocumentRetrievalDriver::read (
}
// Read header section
if (!theHeaderData.Read (*aFileDriver))
if (!theHeaderData.Read (aFileDriver))
raiseOnStorageError (theHeaderData.ErrorStatus());
// Read type section
Storage_TypeData aTypeData;
if (!aTypeData.Read (*aFileDriver))
if (!aTypeData.Read (aFileDriver))
raiseOnStorageError (aTypeData.ErrorStatus());
// Read root section
Storage_RootData aRootData;
if (!aRootData.Read (*aFileDriver))
if (!aRootData.Read (aFileDriver))
raiseOnStorageError (aRootData.ErrorStatus());
if (aRootData.NumberOfRoots() < 1)
@ -169,7 +167,7 @@ Handle(StdObjMgt_Persistent) StdLDrivers_DocumentRetrievalDriver::read (
}
// Read and parse reference section
StdObjMgt_ReadData aReadData (*aFileDriver, theHeaderData.NumberOfObjects());
StdObjMgt_ReadData aReadData (aFileDriver, theHeaderData.NumberOfObjects());
raiseOnStorageError (aFileDriver->BeginReadRefSection());

4
src/StdObjMgt/StdObjMgt_ReadData.cxx
View File

@ -18,8 +18,8 @@
StdObjMgt_ReadData::StdObjMgt_ReadData
(Storage_BaseDriver& theDriver, const Standard_Integer theNumberOfObjects)
: myDriver (&theDriver)
(const Handle(Storage_BaseDriver)& theDriver, const Standard_Integer theNumberOfObjects)
: myDriver (theDriver)
, myPersistentObjects (1, theNumberOfObjects) {}
void StdObjMgt_ReadData::ReadPersistentObject (const Standard_Integer theRef)

4
src/StdObjMgt/StdObjMgt_ReadData.hxx
View File

@ -46,7 +46,7 @@ public:
};
Standard_EXPORT StdObjMgt_ReadData
(Storage_BaseDriver& theDriver, const Standard_Integer theNumberOfObjects);
(const Handle(Storage_BaseDriver)& theDriver, const Standard_Integer theNumberOfObjects);
template <class Instantiator>
void CreatePersistentObject
@ -101,7 +101,7 @@ public:
{ return ReadValue (theValue); }
private:
Storage_BaseDriver* myDriver;
Handle(Storage_BaseDriver) myDriver;
NCollection_Array1<Handle(StdObjMgt_Persistent)> myPersistentObjects;
};

4
src/StdObjMgt/StdObjMgt_WriteData.cxx
View File

@ -17,8 +17,8 @@
#include <Standard_GUID.hxx>
StdObjMgt_WriteData::StdObjMgt_WriteData (Storage_BaseDriver& theDriver)
: myDriver (&theDriver)
StdObjMgt_WriteData::StdObjMgt_WriteData (const Handle(Storage_BaseDriver)& theDriver)
: myDriver (theDriver)
{
}

8
src/StdObjMgt/StdObjMgt_WriteData.hxx
View File

@ -44,11 +44,9 @@ public:
ObjectSentry& operator = (const ObjectSentry&);
};
Standard_EXPORT StdObjMgt_WriteData
(Storage_BaseDriver& theDriver);
Standard_EXPORT StdObjMgt_WriteData (const Handle(Storage_BaseDriver)& theDriver);
Standard_EXPORT void WritePersistentObject
(const Handle(StdObjMgt_Persistent)& thePersistent);
Standard_EXPORT void WritePersistentObject (const Handle(StdObjMgt_Persistent)& thePersistent);
template <class Persistent>
StdObjMgt_WriteData& operator << (const Handle(Persistent)& thePersistent)
@ -85,7 +83,7 @@ public:
{ return WriteValue(theValue); }
private:
Storage_BaseDriver* myDriver;
Handle(Storage_BaseDriver) myDriver;
};
Standard_EXPORT StdObjMgt_WriteData& operator <<

38
src/StdStorage/StdStorage.cxx
View File

@ -54,31 +54,29 @@ Storage_Error StdStorage::Read(const TCollection_AsciiString& theFileName,
Handle(StdStorage_Data)& theData)
{
// Create a driver appropriate for the given file
PCDM_BaseDriverPointer aDriverPtr;
if (PCDM::FileDriverType(theFileName, aDriverPtr) == PCDM_TOFD_Unknown)
Handle(Storage_BaseDriver) aDriver;
if (PCDM::FileDriverType(theFileName, aDriver) == PCDM_TOFD_Unknown)
return Storage_VSWrongFileDriver;
NCollection_Handle<Storage_BaseDriver> aDriver(aDriverPtr);
// Try to open the file
try
{
OCC_CATCH_SIGNALS
PCDM_ReadWriter::Open(*aDriver, theFileName, Storage_VSRead);
PCDM_ReadWriter::Open(aDriver, theFileName, Storage_VSRead);
}
catch (Standard_Failure const&)
{
return Storage_VSOpenError;
}
return Read(*aDriver, theData);
return Read(aDriver, theData);
}
//=======================================================================
// StdStorage::Read
// Reads data from a pre-opened for reading driver
//=======================================================================
Storage_Error StdStorage::Read(Storage_BaseDriver& theDriver,
Storage_Error StdStorage::Read(const Handle(Storage_BaseDriver)& theDriver,
Handle(StdStorage_Data)& theData)
{
if (theData.IsNull())
@ -120,18 +118,18 @@ Storage_Error StdStorage::Read(Storage_BaseDriver& theDriver,
// Read and parse reference section
StdObjMgt_ReadData aReadData(theDriver, aHeaderData->NumberOfObjects());
anError = theDriver.BeginReadRefSection();
anError = theDriver->BeginReadRefSection();
if (anError != Storage_VSOk)
return anError;
Standard_Integer aNbRefs = theDriver.RefSectionSize();
Standard_Integer aNbRefs = theDriver->RefSectionSize();
for (Standard_Integer i = 1; i <= aNbRefs; i++)
{
Standard_Integer aRef = 0, aType = 0;
try
{
OCC_CATCH_SIGNALS
theDriver.ReadReferenceType(aRef, aType);
theDriver->ReadReferenceType(aRef, aType);
anError = Storage_VSOk;
}
catch (Storage_StreamTypeMismatchError const&)
@ -145,12 +143,12 @@ Storage_Error StdStorage::Read(Storage_BaseDriver& theDriver,
aReadData.CreatePersistentObject(aRef, anInstantiators(aType));
}
anError = theDriver.EndReadRefSection();
anError = theDriver->EndReadRefSection();
if (anError != Storage_VSOk)
return anError;
// Read and parse data section
anError = theDriver.BeginReadDataSection();
anError = theDriver->BeginReadDataSection();
if (anError != Storage_VSOk)
return anError;
@ -170,7 +168,7 @@ Storage_Error StdStorage::Read(Storage_BaseDriver& theDriver,
return anError;
}
anError = theDriver.EndReadDataSection();
anError = theDriver->EndReadDataSection();
if (anError != Storage_VSOk)
return anError;
@ -211,7 +209,7 @@ static TCollection_AsciiString currentDate()
//=======================================================================
// StdStorage::Write
//=======================================================================
Storage_Error StdStorage::Write(Storage_BaseDriver& theDriver,
Storage_Error StdStorage::Write(const Handle(Storage_BaseDriver)& theDriver,
const Handle(StdStorage_Data)& theData)
{
Standard_NullObject_Raise_if(theData.IsNull(), "Null storage data");
@ -278,24 +276,24 @@ Storage_Error StdStorage::Write(Storage_BaseDriver& theDriver,
Storage_Error anError;
// Write reference section
anError = theDriver.BeginWriteRefSection();
anError = theDriver->BeginWriteRefSection();
if (anError != Storage_VSOk)
return anError;
theDriver.SetRefSectionSize(aPObjs.Length());
theDriver->SetRefSectionSize(aPObjs.Length());
for (StdStorage_BucketIterator anIt(&aPObjs); anIt.More(); anIt.Next())
{
Handle(StdObjMgt_Persistent) aPObj = anIt.Value();
if (!aPObj.IsNull())
theDriver.WriteReferenceType(aPObj->RefNum(), aPObj->TypeNum());
theDriver->WriteReferenceType(aPObj->RefNum(), aPObj->TypeNum());
}
anError = theDriver.EndWriteRefSection();
anError = theDriver->EndWriteRefSection();
if (anError != Storage_VSOk)
return anError;
// Write data section
anError = theDriver.BeginWriteDataSection();
anError = theDriver->BeginWriteDataSection();
if (anError != Storage_VSOk)
return anError;
@ -307,7 +305,7 @@ Storage_Error StdStorage::Write(Storage_BaseDriver& theDriver,
aWriteData.WritePersistentObject(aPObj);
}
anError = theDriver.EndWriteDataSection();
anError = theDriver->EndWriteDataSection();
if (anError != Storage_VSOk)
return anError;
}

4
src/StdStorage/StdStorage.hxx
View File

@ -57,14 +57,14 @@ public:
//! These data are aggregated in a StdStorage_Data object which may be
//! browsed in order to extract the root objects from the container.
//! Note: - theData object will be created if it is null or cleared otherwise.
Standard_EXPORT static Storage_Error Read(Storage_BaseDriver& theDriver,
Standard_EXPORT static Storage_Error Read(const Handle(Storage_BaseDriver)& theDriver,
Handle(StdStorage_Data)& theData);
//! Writes the data aggregated in theData object into the container defined by
//! theDriver. The storage format is compartible with legacy persistent one.
//! Note: - theData may aggregate several root objects to be stored together.
//! - createion date specified in the srorage header will be overwritten.
Standard_EXPORT static Storage_Error Write(Storage_BaseDriver& theDriver,
Standard_EXPORT static Storage_Error Write(const Handle(Storage_BaseDriver)& theDriver,
const Handle(StdStorage_Data)& theData);
};

54
src/StdStorage/StdStorage_HeaderData.cxx
View File

@ -26,11 +26,11 @@ StdStorage_HeaderData::StdStorage_HeaderData()
{
}
Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
Standard_Boolean StdStorage_HeaderData::Read(const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSRead
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -38,7 +38,7 @@ Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
}
// Read info section
myErrorStatus = theDriver.BeginReadInfoSection();
myErrorStatus = theDriver->BeginReadInfoSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadInfoSection";
@ -48,15 +48,8 @@ Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
try
{
OCC_CATCH_SIGNALS
theDriver.ReadInfo(myNBObj,
myStorageVersion,
myDate,
mySchemaName,
mySchemaVersion,
myApplicationName,
myApplicationVersion,
myDataType,
myUserInfo);
theDriver->ReadInfo(myNBObj, myStorageVersion, myDate, mySchemaName, mySchemaVersion,
myApplicationName, myApplicationVersion, myDataType, myUserInfo);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -71,7 +64,7 @@ Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
return Standard_False;
}
myErrorStatus = theDriver.EndReadInfoSection();
myErrorStatus = theDriver->EndReadInfoSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadInfoSection";
@ -79,7 +72,7 @@ Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
}
// Read comment section
myErrorStatus = theDriver.BeginReadCommentSection();
myErrorStatus = theDriver->BeginReadCommentSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadCommentSection";
@ -89,7 +82,7 @@ Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
try
{
OCC_CATCH_SIGNALS
theDriver.ReadComment(myComments);
theDriver->ReadComment(myComments);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -104,7 +97,7 @@ Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
return Standard_False;
}
myErrorStatus = theDriver.EndReadCommentSection();
myErrorStatus = theDriver->EndReadCommentSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadCommentSection";
@ -114,11 +107,11 @@ Standard_Boolean StdStorage_HeaderData::Read(Storage_BaseDriver& theDriver)
return Standard_True;
}
Standard_Boolean StdStorage_HeaderData::Write(Storage_BaseDriver& theDriver)
Standard_Boolean StdStorage_HeaderData::Write(const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSWrite
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSWrite
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -126,7 +119,7 @@ Standard_Boolean StdStorage_HeaderData::Write(Storage_BaseDriver& theDriver)
}
// Write info section
myErrorStatus = theDriver.BeginWriteInfoSection();
myErrorStatus = theDriver->BeginWriteInfoSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginWriteInfoSection";
@ -136,15 +129,8 @@ Standard_Boolean StdStorage_HeaderData::Write(Storage_BaseDriver& theDriver)
try
{
OCC_CATCH_SIGNALS
theDriver.WriteInfo(myNBObj,
myStorageVersion,
myDate,
mySchemaName,
mySchemaVersion,
myApplicationName,
myApplicationVersion,
myDataType,
myUserInfo);
theDriver->WriteInfo(myNBObj, myStorageVersion, myDate, mySchemaName, mySchemaVersion,
myApplicationName, myApplicationVersion, myDataType, myUserInfo);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -159,7 +145,7 @@ Standard_Boolean StdStorage_HeaderData::Write(Storage_BaseDriver& theDriver)
return Standard_False;
}
myErrorStatus = theDriver.EndWriteInfoSection();
myErrorStatus = theDriver->EndWriteInfoSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndWriteInfoSection";
@ -167,7 +153,7 @@ Standard_Boolean StdStorage_HeaderData::Write(Storage_BaseDriver& theDriver)
}
// Write comment section
myErrorStatus = theDriver.BeginWriteCommentSection();
myErrorStatus = theDriver->BeginWriteCommentSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginWriteCommentSection";
@ -177,7 +163,7 @@ Standard_Boolean StdStorage_HeaderData::Write(Storage_BaseDriver& theDriver)
try
{
OCC_CATCH_SIGNALS
theDriver.WriteComment(myComments);
theDriver->WriteComment(myComments);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -192,7 +178,7 @@ Standard_Boolean StdStorage_HeaderData::Write(Storage_BaseDriver& theDriver)
return Standard_False;
}
myErrorStatus = theDriver.EndWriteCommentSection();
myErrorStatus = theDriver->EndWriteCommentSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndWriteCommentSection";

4
src/StdStorage/StdStorage_HeaderData.hxx
View File

@ -47,13 +47,13 @@ public:
//! Returns Standard_True in case of success. Otherwise, one need to get
//! an error code and description using ErrorStatus and ErrorStatusExtension
//! functions correspondingly.
Standard_EXPORT Standard_Boolean Read(Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Read(const Handle(Storage_BaseDriver)& theDriver);
//! Writes the header data section to the container defined by theDriver.
//! Returns Standard_True in case of success. Otherwise, one need to get
//! an error code and description using ErrorStatus and ErrorStatusExtension
//! functions correspondingly.
Standard_EXPORT Standard_Boolean Write(Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Write(const Handle(Storage_BaseDriver)& theDriver);
//! Return the creation date
Standard_EXPORT TCollection_AsciiString CreationDate() const;

28
src/StdStorage/StdStorage_RootData.cxx
View File

@ -28,11 +28,11 @@ StdStorage_RootData::StdStorage_RootData()
{
}
Standard_Boolean StdStorage_RootData::Read(Storage_BaseDriver& theDriver)
Standard_Boolean StdStorage_RootData::Read(const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSRead
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -40,7 +40,7 @@ Standard_Boolean StdStorage_RootData::Read(Storage_BaseDriver& theDriver)
}
// Read root section
myErrorStatus = theDriver.BeginReadRootSection();
myErrorStatus = theDriver->BeginReadRootSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadRootSection";
@ -50,13 +50,13 @@ Standard_Boolean StdStorage_RootData::Read(Storage_BaseDriver& theDriver)
TCollection_AsciiString aRootName, aTypeName;
Standard_Integer aRef;
Standard_Integer len = theDriver.RootSectionSize();
Standard_Integer len = theDriver->RootSectionSize();
for (Standard_Integer i = 1; i <= len; i++)
{
try
{
OCC_CATCH_SIGNALS
theDriver.ReadRoot(aRootName, aRef, aTypeName);
theDriver->ReadRoot(aRootName, aRef, aTypeName);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -69,7 +69,7 @@ Standard_Boolean StdStorage_RootData::Read(Storage_BaseDriver& theDriver)
myObjects.Add(aRootName, aRoot);
}
myErrorStatus = theDriver.EndReadRootSection();
myErrorStatus = theDriver->EndReadRootSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadRootSection";
@ -79,11 +79,11 @@ Standard_Boolean StdStorage_RootData::Read(Storage_BaseDriver& theDriver)
return Standard_True;
}
Standard_Boolean StdStorage_RootData::Write(Storage_BaseDriver& theDriver)
Standard_Boolean StdStorage_RootData::Write(const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSWrite
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSWrite
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -91,21 +91,21 @@ Standard_Boolean StdStorage_RootData::Write(Storage_BaseDriver& theDriver)
}
// Write root section
myErrorStatus = theDriver.BeginWriteRootSection();
myErrorStatus = theDriver->BeginWriteRootSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginWriteRootSection";
return Standard_False;
}
theDriver.SetRootSectionSize(NumberOfRoots());
theDriver->SetRootSectionSize(NumberOfRoots());
for (StdStorage_MapOfRoots::Iterator anIt(myObjects); anIt.More(); anIt.Next())
{
const Handle(StdStorage_Root)& aRoot = anIt.Value();
try
{
OCC_CATCH_SIGNALS
theDriver.WriteRoot(aRoot->Name(), aRoot->Reference(), aRoot->Type());
theDriver->WriteRoot(aRoot->Name(), aRoot->Reference(), aRoot->Type());
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -115,7 +115,7 @@ Standard_Boolean StdStorage_RootData::Write(Storage_BaseDriver& theDriver)
}
}
myErrorStatus = theDriver.EndWriteRootSection();
myErrorStatus = theDriver->EndWriteRootSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndWriteRootSection";

4
src/StdStorage/StdStorage_RootData.hxx
View File

@ -48,13 +48,13 @@ public:
//! Returns Standard_True in case of success. Otherwise, one need to get
//! an error code and description using ErrorStatus and ErrorStatusExtension
//! functions correspondingly.
Standard_EXPORT Standard_Boolean Read(Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Read(const Handle(Storage_BaseDriver)& theDriver);
//! Writes the root data section to the container defined by theDriver.
//! Returns Standard_True in case of success. Otherwise, one need to get
//! an error code and description using ErrorStatus and ErrorStatusExtension
//! functions correspondingly.
Standard_EXPORT Standard_Boolean Write(Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Write(const Handle(Storage_BaseDriver)& theDriver);
//! Returns the number of roots.
Standard_EXPORT Standard_Integer NumberOfRoots() const;

28
src/StdStorage/StdStorage_TypeData.cxx
View File

@ -28,11 +28,11 @@ StdStorage_TypeData::StdStorage_TypeData()
StdDrivers::BindTypes(myMapOfPInst);
}
Standard_Boolean StdStorage_TypeData::Read(Storage_BaseDriver& theDriver)
Standard_Boolean StdStorage_TypeData::Read(const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSRead
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -40,7 +40,7 @@ Standard_Boolean StdStorage_TypeData::Read(Storage_BaseDriver& theDriver)
}
// Read type section
myErrorStatus = theDriver.BeginReadTypeSection();
myErrorStatus = theDriver->BeginReadTypeSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadTypeSection";
@ -50,13 +50,13 @@ Standard_Boolean StdStorage_TypeData::Read(Storage_BaseDriver& theDriver)
Standard_Integer aTypeNum;
TCollection_AsciiString aTypeName;
Standard_Integer len = theDriver.TypeSectionSize();
Standard_Integer len = theDriver->TypeSectionSize();
for (Standard_Integer i = 1; i <= len; i++)
{
try
{
OCC_CATCH_SIGNALS
theDriver.ReadTypeInformations (aTypeNum, aTypeName);
theDriver->ReadTypeInformations (aTypeNum, aTypeName);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -68,7 +68,7 @@ Standard_Boolean StdStorage_TypeData::Read(Storage_BaseDriver& theDriver)
myPt.Add (aTypeName, aTypeNum);
}
myErrorStatus = theDriver.EndReadTypeSection();
myErrorStatus = theDriver->EndReadTypeSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadTypeSection";
@ -78,11 +78,11 @@ Standard_Boolean StdStorage_TypeData::Read(Storage_BaseDriver& theDriver)
return Standard_True;
}
Standard_Boolean StdStorage_TypeData::Write(Storage_BaseDriver& theDriver)
Standard_Boolean StdStorage_TypeData::Write(const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSWrite
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSWrite
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -90,7 +90,7 @@ Standard_Boolean StdStorage_TypeData::Write(Storage_BaseDriver& theDriver)
}
// Write type section
myErrorStatus = theDriver.BeginWriteTypeSection();
myErrorStatus = theDriver->BeginWriteTypeSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginWriteTypeSection";
@ -98,13 +98,13 @@ Standard_Boolean StdStorage_TypeData::Write(Storage_BaseDriver& theDriver)
}
Standard_Integer len = NumberOfTypes();
theDriver.SetTypeSectionSize(len);
theDriver->SetTypeSectionSize(len);
for (Standard_Integer i = 1; i <= len; i++)
{
try
{
OCC_CATCH_SIGNALS
theDriver.WriteTypeInformations(i, Type(i));
theDriver->WriteTypeInformations(i, Type(i));
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -114,7 +114,7 @@ Standard_Boolean StdStorage_TypeData::Write(Storage_BaseDriver& theDriver)
}
}
myErrorStatus = theDriver.EndWriteTypeSection();
myErrorStatus = theDriver->EndWriteTypeSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndWriteTypeSection";

4
src/StdStorage/StdStorage_TypeData.hxx
View File

@ -47,13 +47,13 @@ public:
//! Returns Standard_True in case of success. Otherwise, one need to get
//! an error code and description using ErrorStatus and ErrorStatusExtension
//! functions correspondingly.
Standard_EXPORT Standard_Boolean Read(Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Read(const Handle(Storage_BaseDriver)& theDriver);
//! Writes the type data section to the container defined by theDriver.
//! Returns Standard_True in case of success. Otherwise, one need to get
//! an error code and description using ErrorStatus and ErrorStatusExtension
//! functions correspondingly.
Standard_EXPORT Standard_Boolean Write(Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Write(const Handle(Storage_BaseDriver)& theDriver);
//! Returns the number of registered types
Standard_EXPORT Standard_Integer NumberOfTypes() const;

2
src/Storage/FILES
View File

@ -4,7 +4,6 @@ Storage_ArrayOfCallBack.hxx
Storage_ArrayOfSchema.hxx
Storage_BaseDriver.cxx
Storage_BaseDriver.hxx
Storage_BaseDriver.lxx
Storage_BucketOfPersistent.hxx
Storage_CallBack.cxx
Storage_CallBack.hxx
@ -36,7 +35,6 @@ Storage_RootData.cxx
Storage_RootData.hxx
Storage_Schema.cxx
Storage_Schema.hxx
Storage_Schema.lxx
Storage_SeqOfRoot.hxx
Storage_SolveMode.hxx
Storage_StreamExtCharParityError.hxx

2
src/Storage/Storage_BaseDriver.cxx
View File

@ -21,6 +21,8 @@
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Storage_BaseDriver, Standard_Transient)
Storage_BaseDriver::Storage_BaseDriver() : myOpenMode(Storage_VSNone)
{
}

196
src/Storage/Storage_BaseDriver.hxx
View File

@ -17,23 +17,16 @@
#ifndef _Storage_BaseDriver_HeaderFile
#define _Storage_BaseDriver_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Type.hxx>
#include <Storage_OpenMode.hxx>
#include <TCollection_AsciiString.hxx>
#include <Storage_Error.hxx>
#include <Standard_Boolean.hxx>
#include <Storage_Data.hxx>
#include <Storage_Position.hxx>
#include <Standard_Integer.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_SequenceOfExtendedString.hxx>
#include <Standard_Character.hxx>
#include <Standard_ExtCharacter.hxx>
#include <Standard_Real.hxx>
#include <Standard_ShortReal.hxx>
class Storage_StreamTypeMismatchError;
class Storage_StreamFormatError;
class Storage_StreamWriteError;
@ -41,27 +34,32 @@ class Storage_StreamExtCharParityError;
class TCollection_AsciiString;
class TCollection_ExtendedString;
DEFINE_STANDARD_HANDLE(Storage_BaseDriver,Standard_Transient)
//! Root class for drivers. A driver assigns a physical container
//! to data to be stored or retrieved, for instance a file.
//! The FSD package provides two derived concrete classes :
//! - FSD_File is a general driver which defines a
//! file as the container of data.
class Storage_BaseDriver
class Storage_BaseDriver : public Standard_Transient
{
public:
DEFINE_STANDARD_RTTIEXT(Storage_BaseDriver,Standard_Transient)
DEFINE_STANDARD_ALLOC
public:
Standard_EXPORT virtual ~Storage_BaseDriver();
Standard_EXPORT virtual Storage_Error Open (const TCollection_AsciiString& aName, const Storage_OpenMode aMode) = 0;
TCollection_AsciiString Name() const { return myName; }
TCollection_AsciiString Name() const;
Storage_OpenMode OpenMode() const;
Storage_OpenMode OpenMode() const { return myOpenMode; }
Standard_EXPORT static TCollection_AsciiString ReadMagicNumber (Standard_IStream& theIStream);
Standard_EXPORT static TCollection_AsciiString ReadMagicNumber(Standard_IStream& theIStream);
public:
//!@name Virtual methods, to be provided by descendants
Standard_EXPORT virtual Storage_Error Open (const TCollection_AsciiString& aName, const Storage_OpenMode aMode) = 0;
//! returns True if we are at end of the stream
Standard_EXPORT virtual Standard_Boolean IsEnd() = 0;
@ -173,114 +171,102 @@ public:
Standard_EXPORT virtual void SkipObject() = 0;
Standard_EXPORT virtual Storage_Error Close() = 0;
public:
//!@name Ouput methods
Standard_EXPORT virtual Storage_BaseDriver& PutReference (const Standard_Integer aValue) = 0;
Standard_EXPORT virtual Storage_BaseDriver& PutCharacter (const Standard_Character aValue) = 0;
Storage_BaseDriver& operator << (const Standard_Character aValue)
{
return PutCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutExtCharacter (const Standard_ExtCharacter aValue) = 0;
Storage_BaseDriver& operator << (const Standard_ExtCharacter aValue)
{
return PutExtCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutInteger (const Standard_Integer aValue) = 0;
Storage_BaseDriver& operator << (const Standard_Integer aValue)
{
return PutInteger(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutBoolean (const Standard_Boolean aValue) = 0;
Storage_BaseDriver& operator << (const Standard_Boolean aValue)
{
return PutBoolean(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutReal (const Standard_Real aValue) = 0;
Storage_BaseDriver& operator << (const Standard_Real aValue)
{
return PutReal(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutShortReal (const Standard_ShortReal aValue) = 0;
Storage_BaseDriver& operator << (const Standard_ShortReal aValue)
{
return PutShortReal(aValue);
}
Storage_BaseDriver& operator << (const Standard_Character aValue)
{
return PutCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutExtCharacter(const Standard_ExtCharacter aValue) = 0;
Storage_BaseDriver& operator << (const Standard_ExtCharacter aValue)
{
return PutExtCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutInteger(const Standard_Integer aValue) = 0;
Storage_BaseDriver& operator << (const Standard_Integer aValue)
{
return PutInteger(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutBoolean(const Standard_Boolean aValue) = 0;
Storage_BaseDriver& operator << (const Standard_Boolean aValue)
{
return PutBoolean(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutReal(const Standard_Real aValue) = 0;
Storage_BaseDriver& operator << (const Standard_Real aValue)
{
return PutReal(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& PutShortReal(const Standard_ShortReal aValue) = 0;
Storage_BaseDriver& operator << (const Standard_ShortReal aValue)
{
return PutShortReal(aValue);
}
public:
//!@name Input methods
Standard_EXPORT virtual Storage_BaseDriver& GetReference (Standard_Integer& aValue) = 0;
Standard_EXPORT virtual Storage_BaseDriver& GetCharacter (Standard_Character& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_Character& aValue)
{
return GetCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetExtCharacter (Standard_ExtCharacter& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_ExtCharacter& aValue)
{
return GetExtCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetInteger (Standard_Integer& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_Integer& aValue)
{
return GetInteger(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetBoolean (Standard_Boolean& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_Boolean& aValue)
{
return GetBoolean(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetReal (Standard_Real& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_Real& aValue)
{
return GetReal(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetShortReal (Standard_ShortReal& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_ShortReal& aValue)
{
return GetShortReal(aValue);
}
Standard_EXPORT virtual Storage_Error Close() = 0;
Storage_BaseDriver& operator >> (Standard_Character& aValue)
{
return GetCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetExtCharacter(Standard_ExtCharacter& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_ExtCharacter& aValue)
{
return GetExtCharacter(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetInteger(Standard_Integer& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_Integer& aValue)
{
return GetInteger(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetBoolean(Standard_Boolean& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_Boolean& aValue)
{
return GetBoolean(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetReal(Standard_Real& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_Real& aValue)
{
return GetReal(aValue);
}
Standard_EXPORT virtual Storage_BaseDriver& GetShortReal(Standard_ShortReal& aValue) = 0;
Storage_BaseDriver& operator >> (Standard_ShortReal& aValue)
{
return GetShortReal(aValue);
}
protected:
Standard_EXPORT Storage_BaseDriver();
void SetName (const TCollection_AsciiString& aName);
void SetOpenMode (const Storage_OpenMode aMode);
void SetName(const TCollection_AsciiString& aName) { myName = aName; }
void SetOpenMode(const Storage_OpenMode aMode) { myOpenMode = aMode; }
private:
Storage_OpenMode myOpenMode;
TCollection_AsciiString myName;
};
#include <Storage_BaseDriver.lxx>
#endif // _Storage_BaseDriver_HeaderFile

34
src/Storage/Storage_BaseDriver.lxx
View File

@ -1,34 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
inline TCollection_AsciiString Storage_BaseDriver::Name() const
{
return myName;
}
inline Storage_OpenMode Storage_BaseDriver::OpenMode() const
{
return myOpenMode;
}
inline void Storage_BaseDriver::SetName(const TCollection_AsciiString& aName)
{
myName = aName;
}
inline void Storage_BaseDriver::SetOpenMode(const Storage_OpenMode aMode)
{
myOpenMode = aMode;
}

30
src/Storage/Storage_CallBack.hxx
View File

@ -29,42 +29,24 @@ class Storage_BaseDriver;
class Storage_CallBack;
DEFINE_STANDARD_HANDLE(Storage_CallBack, Standard_Transient)
class Storage_CallBack : public Standard_Transient
{
public:
Standard_EXPORT virtual Handle(Standard_Persistent) New() const = 0;
Standard_EXPORT virtual void Add (const Handle(Standard_Persistent)& aPers, const Handle(Storage_Schema)& aSchema) const = 0;
Standard_EXPORT virtual void Write (const Handle(Standard_Persistent)& aPers, Storage_BaseDriver& aDriver, const Handle(Storage_Schema)& aSchema) const = 0;
Standard_EXPORT virtual void Write (const Handle(Standard_Persistent)& aPers,
const Handle(Storage_BaseDriver)& aDriver,
const Handle(Storage_Schema)& aSchema) const = 0;
Standard_EXPORT virtual void Read (const Handle(Standard_Persistent)& aPers, Storage_BaseDriver& aDriver, const Handle(Storage_Schema)& aSchema) const = 0;
Standard_EXPORT virtual void Read (const Handle(Standard_Persistent)& aPers,
const Handle(Storage_BaseDriver)& aDriver,
const Handle(Storage_Schema)& aSchema) const = 0;
DEFINE_STANDARD_RTTIEXT(Storage_CallBack,Standard_Transient)
protected:
private:
};
#endif // _Storage_CallBack_HeaderFile

10
src/Storage/Storage_DefaultCallBack.cxx
View File

@ -36,11 +36,15 @@ void Storage_DefaultCallBack::Add(const Handle(Standard_Persistent)&, const Hand
{
}
void Storage_DefaultCallBack::Write(const Handle(Standard_Persistent)&,Storage_BaseDriver&,const Handle(Storage_Schema)&) const
void Storage_DefaultCallBack::Write(const Handle(Standard_Persistent)&,
const Handle(Storage_BaseDriver)&,
const Handle(Storage_Schema)&) const
{
}
void Storage_DefaultCallBack::Read(const Handle(Standard_Persistent)&,Storage_BaseDriver& f,const Handle(Storage_Schema)&) const
void Storage_DefaultCallBack::Read(const Handle(Standard_Persistent)&,
const Handle(Storage_BaseDriver)& theDriver,
const Handle(Storage_Schema)&) const
{
f.SkipObject();
theDriver->SkipObject();
}

39
src/Storage/Storage_DefaultCallBack.hxx
View File

@ -24,49 +24,30 @@
class Standard_Persistent;
class Storage_Schema;
class Storage_BaseDriver;
class Storage_DefaultCallBack;
DEFINE_STANDARD_HANDLE(Storage_DefaultCallBack, Storage_CallBack)
DEFINE_STANDARD_HANDLE(Storage_DefaultCallBack, Storage_CallBack)
class Storage_DefaultCallBack : public Storage_CallBack
{
public:
Standard_EXPORT Storage_DefaultCallBack();
Standard_EXPORT Handle(Standard_Persistent) New() const Standard_OVERRIDE;
Standard_EXPORT void Add (const Handle(Standard_Persistent)& aPers, const Handle(Storage_Schema)& aSchema) const Standard_OVERRIDE;
Standard_EXPORT void Add (const Handle(Standard_Persistent)& thePers,
const Handle(Storage_Schema)& theSchema) const Standard_OVERRIDE;
Standard_EXPORT void Write (const Handle(Standard_Persistent)& aPers, Storage_BaseDriver& aDriver, const Handle(Storage_Schema)& aSchema) const Standard_OVERRIDE;
Standard_EXPORT void Write (const Handle(Standard_Persistent)& thePers,
const Handle(Storage_BaseDriver)& theDriver,
const Handle(Storage_Schema)& theSchema) const Standard_OVERRIDE;
Standard_EXPORT void Read (const Handle(Standard_Persistent)& aPers, Storage_BaseDriver& aDriver, const Handle(Storage_Schema)& aSchema) const Standard_OVERRIDE;
Standard_EXPORT void Read (const Handle(Standard_Persistent)& thePers,
const Handle(Storage_BaseDriver)& theDriver,
const Handle(Storage_Schema)& theSchema) const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(Storage_DefaultCallBack,Storage_CallBack)
protected:
private:
};
#endif // _Storage_DefaultCallBack_HeaderFile

27
src/Storage/Storage_HeaderData.cxx
View File

@ -27,11 +27,11 @@ Storage_HeaderData::Storage_HeaderData() : myNBObj(0), myErrorStatus(Storage_VSO
{
}
Standard_Boolean Storage_HeaderData::Read (Storage_BaseDriver& theDriver)
Standard_Boolean Storage_HeaderData::Read (const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSRead
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -39,7 +39,7 @@ Standard_Boolean Storage_HeaderData::Read (Storage_BaseDriver& theDriver)
}
// Read info section
myErrorStatus = theDriver.BeginReadInfoSection();
myErrorStatus = theDriver->BeginReadInfoSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadInfoSection";
@ -50,15 +50,8 @@ Standard_Boolean Storage_HeaderData::Read (Storage_BaseDriver& theDriver)
try
{
OCC_CATCH_SIGNALS
theDriver.ReadInfo (myNBObj,
myStorageVersion,
myDate,
mySchemaName,
mySchemaVersion,
myApplicationName,
myApplicationVersion,
myDataType,
myUserInfo);
theDriver->ReadInfo (myNBObj, myStorageVersion, myDate, mySchemaName, mySchemaVersion,
myApplicationName, myApplicationVersion, myDataType, myUserInfo);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -74,7 +67,7 @@ Standard_Boolean Storage_HeaderData::Read (Storage_BaseDriver& theDriver)
}
}
myErrorStatus = theDriver.EndReadInfoSection();
myErrorStatus = theDriver->EndReadInfoSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadInfoSection";
@ -82,7 +75,7 @@ Standard_Boolean Storage_HeaderData::Read (Storage_BaseDriver& theDriver)
}
// Read comment section
myErrorStatus = theDriver.BeginReadCommentSection();
myErrorStatus = theDriver->BeginReadCommentSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadCommentSection";
@ -93,7 +86,7 @@ Standard_Boolean Storage_HeaderData::Read (Storage_BaseDriver& theDriver)
try
{
OCC_CATCH_SIGNALS
theDriver.ReadComment (myComments);
theDriver->ReadComment (myComments);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -109,7 +102,7 @@ Standard_Boolean Storage_HeaderData::Read (Storage_BaseDriver& theDriver)
}
}
myErrorStatus = theDriver.EndReadCommentSection();
myErrorStatus = theDriver->EndReadCommentSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadCommentSection";

2
src/Storage/Storage_HeaderData.hxx
View File

@ -45,7 +45,7 @@ public:
Standard_EXPORT Storage_HeaderData();
Standard_EXPORT Standard_Boolean Read (Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Read (const Handle(Storage_BaseDriver)& theDriver);
//! return the creation date
Standard_EXPORT TCollection_AsciiString CreationDate() const;

14
src/Storage/Storage_RootData.cxx
View File

@ -29,11 +29,11 @@ Storage_RootData::Storage_RootData() : myErrorStatus(Storage_VSOk)
{
}
Standard_Boolean Storage_RootData::Read (Storage_BaseDriver& theDriver)
Standard_Boolean Storage_RootData::Read (const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSRead
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -41,7 +41,7 @@ Standard_Boolean Storage_RootData::Read (Storage_BaseDriver& theDriver)
}
// Read root section
myErrorStatus = theDriver.BeginReadRootSection();
myErrorStatus = theDriver->BeginReadRootSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadRootSection";
@ -51,13 +51,13 @@ Standard_Boolean Storage_RootData::Read (Storage_BaseDriver& theDriver)
TCollection_AsciiString aRootName, aTypeName;
Standard_Integer aRef;
Standard_Integer len = theDriver.RootSectionSize();
Standard_Integer len = theDriver->RootSectionSize();
for (Standard_Integer i = 1; i <= len; i++)
{
try
{
OCC_CATCH_SIGNALS
theDriver.ReadRoot (aRootName, aRef, aTypeName);
theDriver->ReadRoot (aRootName, aRef, aTypeName);
}
catch (Storage_StreamTypeMismatchError const&)
{
@ -70,7 +70,7 @@ Standard_Boolean Storage_RootData::Read (Storage_BaseDriver& theDriver)
myObjects.Bind (aRootName, aRoot);
}
myErrorStatus = theDriver.EndReadRootSection();
myErrorStatus = theDriver->EndReadRootSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadRootSection";

2
src/Storage/Storage_RootData.hxx
View File

@ -47,7 +47,7 @@ public:
Standard_EXPORT Storage_RootData();
Standard_EXPORT Standard_Boolean Read (Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Read (const Handle(Storage_BaseDriver)& theDriver);
//! returns the number of roots.
Standard_EXPORT Standard_Integer NumberOfRoots() const;

65
src/Storage/Storage_Schema.cxx
View File

@ -340,9 +340,8 @@ TCollection_AsciiString Storage_Schema::Name() const
// VSReadWrite
//=======================================================================
void Storage_Schema::Write
(Storage_BaseDriver& f,
const Handle(Storage_Data)& aData) const
void Storage_Schema::Write (const Handle(Storage_BaseDriver)& theDriver,
const Handle(Storage_Data)& aData) const
{
if (aData.IsNull()) return;
@ -384,42 +383,42 @@ void Storage_Schema::Write
aData->HeaderData()->SetSchemaName(myName);
aData->HeaderData()->SetSchemaVersion(myVersion);
if ((f.OpenMode() == Storage_VSWrite) || (f.OpenMode() == Storage_VSReadWrite)) {
if ((theDriver->OpenMode() == Storage_VSWrite) || (theDriver->OpenMode() == Storage_VSReadWrite)) {
try {
OCC_CATCH_SIGNALS
errorContext = "BeginWriteInfoSection";
f.BeginWriteInfoSection();
theDriver->BeginWriteInfoSection();
errorContext = "WriteInfo";
f.WriteInfo(aData->NumberOfObjects(),
aData->StorageVersion(),
aData->CreationDate(),
aData->SchemaName(),
aData->SchemaVersion(),
aData->ApplicationName(),
aData->ApplicationVersion(),
aData->DataType(),
aData->UserInfo());
theDriver->WriteInfo(aData->NumberOfObjects(),
aData->StorageVersion(),
aData->CreationDate(),
aData->SchemaName(),
aData->SchemaVersion(),
aData->ApplicationName(),
aData->ApplicationVersion(),
aData->DataType(),
aData->UserInfo());
errorContext = "EndWriteInfoSection";
f.EndWriteInfoSection();
theDriver->EndWriteInfoSection();
errorContext = "BeginWriteCommentSection";
f.BeginWriteCommentSection();
theDriver->BeginWriteCommentSection();
errorContext = "WriteComment";
f.WriteComment(aData->Comments());
theDriver->WriteComment(aData->Comments());
errorContext = "EndWriteCommentSection";
f.EndWriteCommentSection();
theDriver->EndWriteCommentSection();
Handle(TColStd_HSequenceOfAsciiString) tlist;
tlist = aData->Types();
errorContext = "BeginWriteTypeSection";
f.BeginWriteTypeSection();
theDriver->BeginWriteTypeSection();
len = aData->NumberOfTypes();
Handle(Storage_HArrayOfCallBack) WFunc = new Storage_HArrayOfCallBack(1,len);
f.SetTypeSectionSize(len);
theDriver->SetTypeSectionSize(len);
Storage_DataMapIteratorOfMapOfCallBack cbit(iData->myTypeBinding);
Handle(Storage_TypedCallBack) atcallBack;
@ -431,42 +430,42 @@ void Storage_Schema::Write
errorContext = "WriteTypeInformations";
for (i = 1; i <= len; i++) {
f.WriteTypeInformations(i,tlist->Value(i).ToCString());
theDriver->WriteTypeInformations(i,tlist->Value(i).ToCString());
}
errorContext = "EndWriteTypeSection";
f.EndWriteTypeSection();
theDriver->EndWriteTypeSection();
errorContext = "BeginWriteRootSection";
f.BeginWriteRootSection();
f.SetRootSectionSize(plist->Length());
theDriver->BeginWriteRootSection();
theDriver->SetRootSectionSize(plist->Length());
errorContext = "WriteRoot";
for (i = 1; i <= plist->Length(); i++) {
f.WriteRoot(plist->Value(i)->Name(),i,"PDocStd_Document");
theDriver->WriteRoot(plist->Value(i)->Name(),i,"PDocStd_Document");
}
errorContext = "EndWriteRootSection";
f.EndWriteRootSection();
theDriver->EndWriteRootSection();
errorContext = "BeginWriteRefSection";
f.BeginWriteRefSection();
f.SetRefSectionSize(iData->myObjId - 1);
theDriver->BeginWriteRefSection();
theDriver->SetRefSectionSize(iData->myObjId - 1);
errorContext = "WriteReferenceType";
Storage_BucketIterator bit(&iData->myPtoA);
while(bit.More()) {
p = bit.Value();
if (!p.IsNull()) f.WriteReferenceType(p->_refnum,p->_typenum);
if (!p.IsNull()) theDriver->WriteReferenceType(p->_refnum,p->_typenum);
bit.Next();
}
errorContext = "EndWriteRefSection";
f.EndWriteRefSection();
theDriver->EndWriteRefSection();
errorContext = "BeginWriteDataSection";
f.BeginWriteDataSection();
theDriver->BeginWriteDataSection();
Handle(Storage_Schema) me = this;
@ -477,14 +476,14 @@ void Storage_Schema::Write
while(bit.More()) {
p = bit.Value();
if (!p.IsNull()) {
WFunc->Value(p->_typenum)->Write(p,f,me);
WFunc->Value(p->_typenum)->Write(p, theDriver, me);
p->_typenum = 0;
}
bit.Next();
}
errorContext = "EndWriteDataSection";
f.EndWriteDataSection();
theDriver->EndWriteDataSection();
}
catch(Storage_StreamWriteError const&) {
aData->SetErrorStatus(Storage_VSWriteError);

44
src/Storage/Storage_Schema.hxx
View File

@ -17,18 +17,15 @@
#ifndef _Storage_Schema_HeaderFile
#define _Storage_Schema_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Storage_MapOfCallBack.hxx>
#include <Standard_Boolean.hxx>
#include <TCollection_AsciiString.hxx>
#include <Storage_BaseDriver.hxx>
#include <Storage_HArrayOfSchema.hxx>
#include <Standard_Transient.hxx>
#include <Storage_InternalData.hxx>
#include <Storage_MapOfCallBack.hxx>
#include <Storage_SolveMode.hxx>
#include <TCollection_AsciiString.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
#include <TColStd_HSequenceOfAsciiString.hxx>
#include <Storage_SolveMode.hxx>
#include <Standard_CString.hxx>
class Storage_CallBack;
class Storage_StreamFormatError;
class TCollection_AsciiString;
@ -105,7 +102,7 @@ public:
//! schema with which this algorithm is working.
//! Note: aData may aggregate several root objects
//! to be stored together.
Standard_EXPORT void Write (Storage_BaseDriver& s, const Handle(Storage_Data)& aData) const;
Standard_EXPORT void Write (const Handle(Storage_BaseDriver)& s, const Handle(Storage_Data)& aData) const;
//! return a current date string
Standard_EXPORT static TCollection_AsciiString ICreationDate();
@ -160,22 +157,28 @@ public:
//! UseDefaultCallBack() is set.
Standard_EXPORT Handle(Storage_CallBack) DefaultCallBack() const;
void WritePersistentObjectHeader (const Handle(Standard_Persistent)& sp, Storage_BaseDriver& s);
void WritePersistentReference (const Handle(Standard_Persistent)& sp, Storage_BaseDriver& s);
void WritePersistentObjectHeader(const Handle(Standard_Persistent)& sp, const Handle(Storage_BaseDriver)& theDriver)
{
theDriver->WritePersistentObjectHeader(sp->_refnum, sp->_typenum);
}
void WritePersistentReference(const Handle(Standard_Persistent)& sp, const Handle(Storage_BaseDriver)& theDriver)
{
theDriver->PutReference(sp.IsNull() ? 0 : sp->_refnum);
}
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;
DEFINE_STANDARD_RTTIEXT(Storage_Schema,Standard_Transient)
protected:
Standard_Boolean HasTypeBinding (const TCollection_AsciiString& aTypeName) const;
Standard_Boolean HasTypeBinding(const TCollection_AsciiString& aTypeName) const
{
return Storage_Schema::ICurrentData()->InternalData()->myTypeBinding.IsBound(aTypeName);
}
Standard_EXPORT void BindType (const TCollection_AsciiString& aTypeName, const Handle(Storage_CallBack)& aCallBack) const;
@ -198,11 +201,4 @@ private:
TCollection_AsciiString myVersion;
};
#include <Storage_Schema.lxx>
#endif // _Storage_Schema_HeaderFile

39
src/Storage/Storage_Schema.lxx
View File

@ -1,39 +0,0 @@
// Copyright (c) 1998-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Storage_Data.hxx>
#include <Storage_InternalData.hxx>
#include <Storage_BaseDriver.hxx>
inline void Storage_Schema::WritePersistentObjectHeader(const Handle(Standard_Persistent)& sp,Storage_BaseDriver& f)
{
f.WritePersistentObjectHeader(sp->_refnum,sp->_typenum);
}
inline Standard_Boolean Storage_Schema::HasTypeBinding(const TCollection_AsciiString& aTypeName) const
{
return Storage_Schema::ICurrentData()->InternalData()->myTypeBinding.IsBound(aTypeName);
}
inline void Storage_Schema::WritePersistentReference(const Handle(Standard_Persistent)& sp,Storage_BaseDriver& f)
{
if (!sp.IsNull()) {
f.PutReference(sp->_refnum);
}
else {
f.PutReference(0);
}
}

14
src/Storage/Storage_TypeData.cxx
View File

@ -26,11 +26,11 @@ Storage_TypeData::Storage_TypeData() : myErrorStatus(Storage_VSOk)
{
}
Standard_Boolean Storage_TypeData::Read (Storage_BaseDriver& theDriver)
Standard_Boolean Storage_TypeData::Read (const Handle(Storage_BaseDriver)& theDriver)
{
// Check driver open mode
if (theDriver.OpenMode() != Storage_VSRead
&& theDriver.OpenMode() != Storage_VSReadWrite)
if (theDriver->OpenMode() != Storage_VSRead
&& theDriver->OpenMode() != Storage_VSReadWrite)
{
myErrorStatus = Storage_VSModeError;
myErrorStatusExt = "OpenMode";
@ -38,7 +38,7 @@ Standard_Boolean Storage_TypeData::Read (Storage_BaseDriver& theDriver)
}
// Read type section
myErrorStatus = theDriver.BeginReadTypeSection();
myErrorStatus = theDriver->BeginReadTypeSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "BeginReadTypeSection";
@ -48,13 +48,13 @@ Standard_Boolean Storage_TypeData::Read (Storage_BaseDriver& theDriver)
Standard_Integer aTypeNum;
TCollection_AsciiString aTypeName;
Standard_Integer len = theDriver.TypeSectionSize();
Standard_Integer len = theDriver->TypeSectionSize();
for (Standard_Integer i = 1; i <= len; i++)
{
try
{
OCC_CATCH_SIGNALS
theDriver.ReadTypeInformations (aTypeNum, aTypeName);
theDriver->ReadTypeInformations (aTypeNum, aTypeName);
}
catch (const Storage_StreamTypeMismatchError&)
{
@ -66,7 +66,7 @@ Standard_Boolean Storage_TypeData::Read (Storage_BaseDriver& theDriver)
myPt.Add (aTypeName, aTypeNum);
}
myErrorStatus = theDriver.EndReadTypeSection();
myErrorStatus = theDriver->EndReadTypeSection();
if (myErrorStatus != Storage_VSOk)
{
myErrorStatusExt = "EndReadTypeSection";

2
src/Storage/Storage_TypeData.hxx
View File

@ -45,7 +45,7 @@ public:
Standard_EXPORT Storage_TypeData();
Standard_EXPORT Standard_Boolean Read (Storage_BaseDriver& theDriver);
Standard_EXPORT Standard_Boolean Read (const Handle(Storage_BaseDriver)& theDriver);
Standard_EXPORT Standard_Integer NumberOfTypes() const;

4
src/UTL/UTL.cxx
View File

@ -50,11 +50,11 @@ TCollection_ExtendedString UTL::Extension(const TCollection_ExtendedString& aFil
return TCollection_ExtendedString(theExtension);
}
Storage_Error UTL::OpenFile(Storage_BaseDriver& aDriver,
Storage_Error UTL::OpenFile(const Handle(Storage_BaseDriver)& aDriver,
const TCollection_ExtendedString& aFileName,
const Storage_OpenMode aMode)
{
return aDriver.Open(TCollection_AsciiString(aFileName),aMode);
return aDriver->Open(TCollection_AsciiString(aFileName),aMode);
}
void UTL::AddToUserInfo(const Handle(Storage_Data)& aData,

4
src/UTL/UTL.hxx
View File

@ -46,7 +46,9 @@ public:
Standard_EXPORT static TCollection_ExtendedString xgetenv (const Standard_CString aCString);
Standard_EXPORT static Storage_Error OpenFile (Storage_BaseDriver& aFile, const TCollection_ExtendedString& aName, const Storage_OpenMode aMode);
Standard_EXPORT static Storage_Error OpenFile (const Handle(Storage_BaseDriver)& aFile,
const TCollection_ExtendedString& aName,
const Storage_OpenMode aMode);
Standard_EXPORT static void AddToUserInfo (const Handle(Storage_Data)& aData, const TCollection_ExtendedString& anInfo);

19
tests/bugs/caf/bug31546 Normal file
View File

@ -0,0 +1,19 @@
puts "==========="
puts "0031546: Application Framework - Memory leak (100 bytes) on Load / Close OCAF document"
puts "==========="
puts "Preparing empty document"
set docname ${imagedir}/${casename}.cbf
NewDocument D BinOcaf
SaveAs D $docname
Close D
puts "Executing Load / Close in cycle to see if allocated heap memory grows"
set listmem {}
for {set i 1} {$i < 10} {incr i} {
Open $docname D
Close D
lappend listmem [meminfo h]
checktrend $listmem 0 0 "Memory leak"
}

2
tests/bugs/fclasses/bug29355
View File

@ -12,5 +12,5 @@ checknbshapes a -face 14 -solid 0 -edge 39 -vertex 26
puts ""
puts "# Check that reading fails with expected message on truncated file"
puts "REQUIRED 29355 ALL: Error : 6"
puts "REQUIRED 29355 ALL: Storage error: the section is not found"
catch {fsdread [locate_data_file bug29355_truncated.fsd] a}