Open CASCADE Technology 6.6.0
Public Member Functions | Static Public Member Functions | Protected Member Functions
Storage_Schema Class Reference

Root class for basic storage/retrieval algorithms.
A Storage_Schema object processes:
More...

#include <Storage_Schema.hxx>

Inheritance diagram for Storage_Schema:
Inheritance graph
[legend]

Public Member Functions

 Storage_Schema ()
 Builds a storage/retrieval algorithm based on a
given data schema.
Example
For example, if ShapeSchema is the class
inheriting from Storage_Schema and containing
the description of your application data schema,
you create a storage/retrieval algorithm as follows:
Handle(ShapeSchema) s = new
ShapeSchema;

void SetVersion (const TCollection_AsciiString &aVersion)
 returns version of the schema

TCollection_AsciiString Version () const
 returns the version of the schema

void SetName (const TCollection_AsciiString &aSchemaName)
 set the schema's name

TCollection_AsciiString Name () const
 returns the schema's name

void Write (Storage_BaseDriver &s, const Handle< Storage_Data > &aData) const
 Writes the data aggregated in aData into the
container defined by the driver s. The storage
operation is performed according to the data
schema with which this algorithm is working.
Note: aData may aggregate several root objects
to be stored together.

Handle_Storage_Data Read (Storage_BaseDriver &s) const
 Returns the data read from the container defined
by the driver s. The retrieval operation is
performed according to the data schema with
which this algorithm is working.
These data are aggregated in a Storage_Data
object which may be browsed in order to extract
the root objects from the container.

Handle_Storage_HeaderData ReadHeaderSection (Storage_BaseDriver &s) const
 read the header part of the stream
Arguments:
s: driver to read

Handle_Storage_TypeData ReadTypeSection (Storage_BaseDriver &s) const
 fill the TypeData with the names of the type used
in a stream
Arguments:
s: driver to read

Handle_Storage_RootData ReadRootSection (Storage_BaseDriver &s) const
 read root part of the file
Arguments:
s: driver to read

virtual const
TColStd_SequenceOfAsciiString
SchemaKnownTypes () const
 returns the known types of a schema

Standard_Boolean HasUnknownType (Storage_BaseDriver &aDriver, TColStd_SequenceOfAsciiString &theUnknownTypes) const
 indicates whether the are types in the driver
which are not known from the schema and for which
no callbacks have been set. The unknown types can
be read in <theUnknownTypes>.

Handle_TColStd_HSequenceOfAsciiString GetAllSchemaKnownTypes () const
 returns the all known types of a schema and their
nested schemes.

void SetNestedSchemas (const Handle< Storage_HArrayOfSchema > &theSchemas)
void ClearNestedSchemas ()
Handle_Storage_HArrayOfSchema NestedSchemas () const
void AddReadUnknownTypeCallBack (const TCollection_AsciiString &aTypeName, const Handle< Storage_CallBack > &aCallBack)
 add two functions to the callback list

void RemoveReadUnknownTypeCallBack (const TCollection_AsciiString &aTypeName)
 remove a callback for a type

Handle_TColStd_HSequenceOfAsciiString InstalledCallBackList () const
 returns a list of type name with installed
callback.

void ClearCallBackList ()
 clear all callback from schema instance.

void UseDefaultCallBack ()
 install a callback for all unknown type. the
objects with unknown types will be skipped. (look
SkipObject method in BaseDriver)

void DontUseDefaultCallBack ()
 tells schema to uninstall the default callback.

Standard_Boolean IsUsingDefaultCallBack () const
 ask if the schema is using the default callback.

void SetDefaultCallBack (const Handle< Storage_CallBack > &f)
 overload the default function for build.(use to
set an error message or skip an object while
reading an unknown type).

void ResetDefaultCallBack ()
 reset the default function defined by Storage
package.

Handle_Storage_CallBack DefaultCallBack () const
 returns the read function used when the
UseDefaultCallBack() is set.

virtual Handle_Storage_CallBack CallBackSelection (const TCollection_AsciiString &tName) const
virtual Handle_Storage_CallBack AddTypeSelection (const Handle< Standard_Persistent > &sp) const
void WritePersistentObjectHeader (const Handle< Standard_Persistent > &sp, Storage_BaseDriver &s)
void ReadPersistentObjectHeader (Storage_BaseDriver &s)
void WritePersistentReference (const Handle< Standard_Persistent > &sp, Storage_BaseDriver &s)
void ReadPersistentReference (Handle< Standard_Persistent > &sp, Storage_BaseDriver &s)
Standard_Boolean AddPersistent (const Handle< Standard_Persistent > &sp, const Standard_CString tName) const
Standard_Boolean PersistentToAdd (const Handle< Standard_Persistent > &sp) const

Static Public Member Functions

static TCollection_AsciiString ICreationDate ()
 return a current date string

static Standard_Boolean CheckTypeMigration (const TCollection_AsciiString &theTypeName, TCollection_AsciiString &theNewName)
 returns True if theType migration is identified
//! the callback support provides a way to read a file
with a incomplete schema.
ex. : A file contains 3 types a,b and c.
The application's schema contains only 2
type a and b. If you try to read the file in
the application, you will have an error.To
bypass this problem you can give to your
application's schema a callback used when
the schema dosent know how to handle this
type.

Protected Member Functions

Standard_Boolean IsNested () const
Handle_Storage_CallBack ResolveUnknownType (const TCollection_AsciiString &aTypeName, const Handle< Standard_Persistent > &aPers, const Storage_SolveMode aMode) const
Standard_Boolean HasTypeBinding (const TCollection_AsciiString &aTypeName) const
void BindType (const TCollection_AsciiString &aTypeName, const Handle< Storage_CallBack > &aCallBack) const
Handle_Storage_CallBack TypeBinding (const TCollection_AsciiString &aTypeName) const

Detailed Description


Constructor & Destructor Documentation

Storage_Schema::Storage_Schema ( )

-------- --
USER API -- --------------------------------------------------------------
-------- --


Member Function Documentation

Standard_Boolean Storage_Schema::AddPersistent ( const Handle< Standard_Persistent > &  sp,
const Standard_CString  tName 
) const
void Storage_Schema::AddReadUnknownTypeCallBack ( const TCollection_AsciiString aTypeName,
const Handle< Storage_CallBack > &  aCallBack 
)
virtual Handle_Storage_CallBack Storage_Schema::AddTypeSelection ( const Handle< Standard_Persistent > &  sp) const [virtual]
void Storage_Schema::BindType ( const TCollection_AsciiString aTypeName,
const Handle< Storage_CallBack > &  aCallBack 
) const [protected]
virtual Handle_Storage_CallBack Storage_Schema::CallBackSelection ( const TCollection_AsciiString tName) const [virtual]
static Standard_Boolean Storage_Schema::CheckTypeMigration ( const TCollection_AsciiString theTypeName,
TCollection_AsciiString theNewName 
) [static]
void Storage_Schema::ClearCallBackList ( )
void Storage_Schema::ClearNestedSchemas ( )
Handle_Storage_CallBack Storage_Schema::DefaultCallBack ( ) const
void Storage_Schema::DontUseDefaultCallBack ( )
Handle_TColStd_HSequenceOfAsciiString Storage_Schema::GetAllSchemaKnownTypes ( ) const
Standard_Boolean Storage_Schema::HasTypeBinding ( const TCollection_AsciiString aTypeName) const [protected]
Standard_Boolean Storage_Schema::HasUnknownType ( Storage_BaseDriver aDriver,
TColStd_SequenceOfAsciiString theUnknownTypes 
) const
static TCollection_AsciiString Storage_Schema::ICreationDate ( ) [static]
Handle_TColStd_HSequenceOfAsciiString Storage_Schema::InstalledCallBackList ( ) const
Standard_Boolean Storage_Schema::IsNested ( ) const [protected]
Standard_Boolean Storage_Schema::IsUsingDefaultCallBack ( ) const
TCollection_AsciiString Storage_Schema::Name ( ) const
Handle_Storage_HArrayOfSchema Storage_Schema::NestedSchemas ( ) const
Standard_Boolean Storage_Schema::PersistentToAdd ( const Handle< Standard_Persistent > &  sp) const
Handle_Storage_Data Storage_Schema::Read ( Storage_BaseDriver s) const
Handle_Storage_HeaderData Storage_Schema::ReadHeaderSection ( Storage_BaseDriver s) const
void Storage_Schema::ReadPersistentObjectHeader ( Storage_BaseDriver s)
void Storage_Schema::ReadPersistentReference ( Handle< Standard_Persistent > &  sp,
Storage_BaseDriver s 
)
Handle_Storage_RootData Storage_Schema::ReadRootSection ( Storage_BaseDriver s) const
Handle_Storage_TypeData Storage_Schema::ReadTypeSection ( Storage_BaseDriver s) const
void Storage_Schema::RemoveReadUnknownTypeCallBack ( const TCollection_AsciiString aTypeName)
void Storage_Schema::ResetDefaultCallBack ( )
Handle_Storage_CallBack Storage_Schema::ResolveUnknownType ( const TCollection_AsciiString aTypeName,
const Handle< Standard_Persistent > &  aPers,
const Storage_SolveMode  aMode 
) const [protected]
virtual const TColStd_SequenceOfAsciiString& Storage_Schema::SchemaKnownTypes ( ) const [virtual]
void Storage_Schema::SetDefaultCallBack ( const Handle< Storage_CallBack > &  f)
void Storage_Schema::SetName ( const TCollection_AsciiString aSchemaName)
void Storage_Schema::SetNestedSchemas ( const Handle< Storage_HArrayOfSchema > &  theSchemas)
void Storage_Schema::SetVersion ( const TCollection_AsciiString aVersion)
Handle_Storage_CallBack Storage_Schema::TypeBinding ( const TCollection_AsciiString aTypeName) const [protected]
void Storage_Schema::UseDefaultCallBack ( )
TCollection_AsciiString Storage_Schema::Version ( ) const
void Storage_Schema::Write ( Storage_BaseDriver s,
const Handle< Storage_Data > &  aData 
) const
void Storage_Schema::WritePersistentObjectHeader ( const Handle< Standard_Persistent > &  sp,
Storage_BaseDriver s 
)
void Storage_Schema::WritePersistentReference ( const Handle< Standard_Persistent > &  sp,
Storage_BaseDriver s 
)

The documentation for this class was generated from the following file:
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines