1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
|
-- File: Storage_Schema.cdl
-- Created: Tue Dec 3 10:05:16 1996
-- Author: Christophe LEYNADIER
-- <cle@parigox.paris1.matra-dtv.fr>
---Copyright: Matra Datavision 1996
class Schema from Storage inherits TShared from MMgt
---Purpose:
-- Root class for basic storage/retrieval algorithms.
-- A Storage_Schema object processes:
-- - writing of a set of persistent data into a
-- container (store mechanism),
-- - reading of a container to extract all the
-- contained persistent data (retrieve mechanism).
-- A Storage_Schema object is based on the data
-- schema for the persistent data of the application, i.e.:
-- - the list of all persistent objects which may be
-- known by the application,
-- - the organization of their data; a data schema
-- knows how to browse each persistent object it contains.
-- During the store or retrieve operation, only
-- persistent objects known from the data schema
-- can be processed; they are then stored or
-- retrieved according to their description in the schema.
-- A data schema is specific to the object classes to
-- be read or written. Tools dedicated to the
-- environment in use allow a description of the
-- application persistent data structure.
-- Storage_Schema algorithms are called basic
-- because they do not support external references
-- between containers.
uses SequenceOfAsciiString from TColStd,
HSequenceOfAsciiString from TColStd,
AsciiString from TCollection,
BaseDriver from Storage,
Data from Storage,
HeaderData from Storage,
MapOfCallBack from Storage,
CallBack from Storage,
CallBack from Storage,
RootData from Storage,
TypeData from Storage,
HArrayOfSchema from Storage,
SolveMode from Storage
raises StreamFormatError from Storage
is
Create returns Schema from Storage;
---Purpose: 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;
-- -------- --
-- USER API -- --------------------------------------------------------------
-- -------- --
SetVersion(me : mutable; aVersion : AsciiString from TCollection);
---Purpose: returns version of the schema
Version(me) returns AsciiString from TCollection;
---Purpose: returns the version of the schema
SetName(me : mutable; aSchemaName : AsciiString from TCollection);
---Purpose: set the schema's name
Name(me) returns AsciiString from TCollection;
---Purpose: returns the schema's name
Write(me; s : in out BaseDriver from Storage;
aData : mutable Data from Storage);
---Purpose: 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.
Read(me; s : in out BaseDriver from Storage)
returns mutable Data from Storage;
---Purpose: 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.
ReadHeaderSection(me; s : in out BaseDriver from Storage)
returns mutable HeaderData from Storage;
---Purpose: read the header part of the stream
-- Arguments:
-- s: driver to read
ReadTypeSection(me; s : in out BaseDriver from Storage)
returns mutable TypeData from Storage;
---Purpose: fill the TypeData with the names of the type used
-- in a stream
-- Arguments:
-- s: driver to read
ReadRootSection(me; s : in out BaseDriver from Storage)
returns mutable RootData from Storage;
---Purpose: read root part of the file
-- Arguments:
-- s: driver to read
SchemaKnownTypes(me)
returns SequenceOfAsciiString from TColStd is virtual;
---C++: return const &
---Purpose: returns the known types of a schema
HasUnknownType(me; aDriver : in out BaseDriver from Storage;
theUnknownTypes : out SequenceOfAsciiString from TColStd)
returns Boolean from Standard;
---Purpose: indicates whether the are types in the driver
-- which are not known from the schema and for which
-- no callbacks have been set. The unknown types can
-- be read in <theUnknownTypes>.
GetAllSchemaKnownTypes(me)
returns HSequenceOfAsciiString from TColStd;
---Purpose: returns the all known types of a schema and their
-- nested schemes.
SetNestedSchemas(me : mutable; theSchemas : HArrayOfSchema from Storage);
ClearNestedSchemas(me : mutable);
NestedSchemas(me) returns HArrayOfSchema from Storage;
ICreationDate(myclass) returns AsciiString from TCollection;
---Purpose: return a current date string
CheckTypeMigration(myclass; theTypeName : AsciiString from TCollection;
theNewName : in out AsciiString from TCollection)
returns Boolean from Standard;
---Purpose: returns True if theType migration is identified
-- --------------------------- --
-- USER API : CALLBACK SUPPORT --
-- --------------------------- --
---Purpose: 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.
---Warning: : the callback can only be used with persistent
-- types (not with storable types). the constructor
-- function can return a null handle the read
-- function can be empty
AddReadUnknownTypeCallBack(me : mutable;
aTypeName : AsciiString from TCollection;
aCallBack : CallBack from Storage);
---Purpose: add two functions to the callback list
RemoveReadUnknownTypeCallBack(me : mutable;
aTypeName : AsciiString from TCollection);
---Purpose: remove a callback for a type
InstalledCallBackList(me)
returns HSequenceOfAsciiString from TColStd;
---Purpose: returns a list of type name with installed
-- callback.
ClearCallBackList(me : mutable);
---Purpose: clear all callback from schema instance.
UseDefaultCallBack(me : mutable);
---Purpose: install a callback for all unknown type. the
-- objects with unknown types will be skipped. (look
-- SkipObject method in BaseDriver)
DontUseDefaultCallBack(me : mutable);
---Purpose: tells schema to uninstall the default callback.
IsUsingDefaultCallBack(me) returns Boolean from Standard;
---Purpose: ask if the schema is using the default callback.
SetDefaultCallBack(me : mutable; f : CallBack from Storage);
---Purpose: overload the default function for build.(use to
-- set an error message or skip an object while
-- reading an unknown type).
ResetDefaultCallBack(me : mutable);
---Purpose: reset the default function defined by Storage
-- package.
DefaultCallBack(me) returns CallBack from Storage;
---Purpose: returns the read function used when the
-- UseDefaultCallBack() is set.
-- ---------------- --
-- INTERNAL METHODS --
-- ---------------- --
SetNested(me : mutable) returns Boolean from Standard is private;
IsNested(me) returns Boolean from Standard is protected;
UnsetNested(me : mutable) returns Boolean from Standard is private;
ResolveUnknownType(me; aTypeName : AsciiString from TCollection;
aPers : Persistent from Standard;
aMode : SolveMode from Storage)
returns CallBack from Storage is protected;
CallBackSelection(me; tName : AsciiString from TCollection)
returns CallBack from Storage is virtual;
---Level: Internal
AddTypeSelection(me; sp : Persistent from Standard)
returns CallBack from Storage is virtual;
---Level: Internal
HasTypeBinding(me; aTypeName : AsciiString from TCollection)
returns Boolean from Standard is protected;
---Level: Internal
---C++: inline
BindType(me; aTypeName : AsciiString from TCollection;
aCallBack : CallBack from Storage) is protected;
---Level: Internal
TypeBinding(me; aTypeName : AsciiString from TCollection)
returns CallBack from Storage is protected;
---Level: Internal
WritePersistentObjectHeader(me : mutable;
sp : Persistent;
s : in out BaseDriver from Storage);
---C++: inline
---Level: Internal
ReadPersistentObjectHeader(me : mutable; s : in out BaseDriver from Storage);
---C++: inline
---Level: Internal
WritePersistentReference(me : mutable; sp : Persistent;
s : in out BaseDriver from Storage);
---C++: inline
ReadPersistentReference(me : mutable; sp : in out Persistent;
s : in out BaseDriver from Storage);
---Level: Internal
AddPersistent(me; sp : Persistent; tName : CString) returns Boolean;
---Level: Internal
PersistentToAdd(me; sp : Persistent) returns Boolean;
---Level: Internal
Clear(me) is private;
---Level: Internal
IReadHeaderSection(me; s : in out BaseDriver from Storage;
iData : mutable HeaderData from Storage) returns Boolean
raises StreamFormatError is private;
---Level: Internal
IReadTypeSection(me; s : in out BaseDriver from Storage;
tData : mutable TypeData from Storage) returns Boolean
raises StreamFormatError is private;
---Level: Internal
IReadRootSection(me; s : in out BaseDriver from Storage;
rData : mutable RootData from Storage) returns Boolean
raises StreamFormatError is private;
---Level: Internal
ISetCurrentData(myclass; dData : mutable Data from Storage) is private;
---Level: Internal
ICurrentData(myclass) returns mutable Data from Storage is private;
---Level: Internal
---C++: return &
fields
myCallBack : MapOfCallBack from Storage;
myCallBackState : Boolean from Standard;
myDefaultCallBack : CallBack from Storage;
myName : AsciiString from TCollection;
myVersion : AsciiString from TCollection;
myArrayOfSchema : HArrayOfSchema from Storage;
myNestedState : Boolean from Standard;
end;
|
