KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > enhydra > shark > api > internal > eventaudit > EventAuditManagerInterface


1 package org.enhydra.shark.api.internal.eventaudit;
2
3
4
5 import java.util.List JavaDoc;
6
7 import org.enhydra.shark.api.RootException;
8
9 import org.enhydra.shark.api.SharkTransaction;
10
11 import org.enhydra.shark.api.internal.working.CallbackUtilities;
12
13
14
15 /**
16
17  * Interface that has to be implemented for each persistent layer that
18
19  * is supposed to be used.
20
21  *
22
23  * @version 1.0
24
25  *
26
27  */

28
29 public interface EventAuditManagerInterface {
30
31
32
33    /**
34
35     * Method configure is called at Shark start up, to configure
36
37     * implementation of EventAuditManagerInterface.
38
39     *
40
41     * @param cus an instance of CallbackUtilities used to get
42
43     * properties for configuring Event Audit Manager in Shark.
44
45     *
46
47     * @exception RootException Thrown if configuring doesn't succeed.
48
49     */

50
51    void configure(CallbackUtilities cus) throws RootException;
52
53
54
55    /**
56
57     * Method persist stores the assignment event into repository
58
59     * (usually database) using supplied transaction.
60
61     *
62
63     * @param assea AssignmentEventAuditPersistenceInterface
64
65     * @param ti SharkTransaction to use.
66
67     *
68
69     * @exception EventAuditException on error.
70
71     */

72
73    public void persist(AssignmentEventAuditPersistenceInterface assea,
74
75                        SharkTransaction ti)
76
77       throws EventAuditException;
78
79
80
81    /**
82
83     * Method persist stores the create process event into repository
84
85     * (usually database) using supplied transaction.
86
87     *
88
89     * @param cpea CreateProcessEventAuditPersistenceInterface
90
91     * @param ti SharkTransaction to use.
92
93     *
94
95     * @exception EventAuditException on error.
96
97     */

98
99    public void persist(CreateProcessEventAuditPersistenceInterface cpea,
100
101                        SharkTransaction ti)
102
103       throws EventAuditException;
104
105
106
107    /**
108
109     * Method persist stores the data event into repository
110
111     * (usually database) using supplied transaction.
112
113     *
114
115     * @param dea DataEventAuditPersistenceInterface
116
117     * @param ti SharkTransaction to use.
118
119     *
120
121     * @exception EventAuditException on error.
122
123     */

124
125    public void persist(DataEventAuditPersistenceInterface dea,
126
127                        SharkTransaction ti)
128
129       throws EventAuditException;
130
131
132
133    /**
134
135     * Method persist stores the state event into repository
136
137     * (usually database) using supplied transaction.
138
139     *
140
141     * @param sea StateEventAuditPersistenceInterface
142
143     * @param ti SharkTransaction to use.
144
145     *
146
147     * @exception EventAuditException on error.
148
149     */

150
151    public void persist(StateEventAuditPersistenceInterface sea,
152
153                        SharkTransaction ti)
154
155       throws EventAuditException;
156
157
158
159    /**
160
161     * Method restore retrieves assignment event from the
162
163     * repository using supplied transaction.
164
165     *
166
167     * @param assea AssignmentEventAuditPersistenceInterface
168
169     * @param ti SharkTransaction to use.
170
171     *
172
173     * @return true on success, false otherwise
174
175     *
176
177     * @exception EventAuditException on error.
178
179     */

180
181    public boolean restore(AssignmentEventAuditPersistenceInterface assea,
182
183                           SharkTransaction ti)
184
185       throws EventAuditException;
186
187
188
189    /**
190
191     * Method restore retrieves create process event from the
192
193     * repository using supplied transaction.
194
195     *
196
197     * @param cpea CreateProcessEventAuditPersistenceInterface
198
199     * @param ti SharkTransaction to use.
200
201     *
202
203     * @return true on success, false otherwise
204
205     *
206
207     * @exception EventAuditException on error.
208
209     */

210
211    public boolean restore(CreateProcessEventAuditPersistenceInterface cpea,
212
213                           SharkTransaction ti)
214
215       throws EventAuditException;
216
217
218
219    /**
220
221     * Method restore retrieves data event from the
222
223     * repository using supplied transaction.
224
225     *
226
227     * @param dea DataEventAuditPersistenceInterface
228
229     * @param ti SharkTransaction to use.
230
231     *
232
233     * @return true on success, false otherwise
234
235     *
236
237     * @exception EventAuditException on error.
238
239     */

240
241    public boolean restore(DataEventAuditPersistenceInterface dea,
242
243                           SharkTransaction ti)
244
245       throws EventAuditException;
246
247
248
249    /**
250
251     * Method restore retrieves state event from the
252
253     * repository using supplied transaction.
254
255     *
256
257     * @param sea StateEventAuditPersistenceInterface
258
259     * @param ti SharkTransaction to use.
260
261     *
262
263     * @return true on success, false otherwise
264
265     *
266
267     * @exception EventAuditException on error.
268
269     */

270
271    public boolean restore(StateEventAuditPersistenceInterface sea,
272
273                           SharkTransaction ti)
274
275       throws EventAuditException;
276
277
278
279     /**
280
281     * Method restoreProcessHistory
282
283     *
284
285     * @param procId a String
286
287     * @param ti SharkTransaction to use.
288
289     *
290
291     * @return a List
292
293     *
294
295     * @exception EventAuditException on error.
296
297     */

298
299    public List JavaDoc restoreProcessHistory(String JavaDoc procId,SharkTransaction ti)
300
301       throws EventAuditException;
302
303
304
305    /**
306
307     * Method restoreActivityHistory
308
309     *
310
311     * @param procId a String
312
313     * @param actId a String
314
315     * @param ti SharkTransaction to use.
316
317     *
318
319     * @return a List
320
321     *
322
323     * @exception EventAuditException on error.
324
325     */

326
327    public List JavaDoc restoreActivityHistory(String JavaDoc procId,
328
329                                       String JavaDoc actId,
330
331                                       SharkTransaction ti)
332
333       throws EventAuditException;
334
335    
336
337    /**
338
339     * Method delete
340
341     *
342
343     * @param assea an AssignmentEventAuditPersistenceInterface
344
345     * @param ti SharkTransaction to use.
346
347     *
348
349     * @exception EventAuditException on error.
350
351     */

352
353    public void delete(AssignmentEventAuditPersistenceInterface assea,
354
355                       SharkTransaction ti)
356
357       throws EventAuditException;
358
359
360
361    /**
362
363     * Method delete
364
365     *
366
367     * @param cpea a CreateProcessEventAuditPersistenceInterface
368
369     * @param ti SharkTransaction to use.
370
371     *
372
373     * @exception EventAuditException on error.
374
375     */

376
377    public void delete(CreateProcessEventAuditPersistenceInterface cpea,
378
379                       SharkTransaction ti)
380
381       throws EventAuditException;
382
383
384
385    /**
386
387     * Method delete
388
389     *
390
391     * @param dea a DataEventAuditPersistenceInterface
392
393     * @param ti SharkTransaction to use.
394
395     *
396
397     * @exception EventAuditException on error.
398
399     */

400
401    public void delete(DataEventAuditPersistenceInterface dea,
402
403                       SharkTransaction ti)
404
405       throws EventAuditException;
406
407
408
409    /**
410
411     * Method delete
412
413     *
414
415     * @param sea a StateEventAuditPersistenceInterface
416
417     * @param ti SharkTransaction to use.
418
419     *
420
421     * @exception EventAuditException on error.
422
423     */

424
425    public void delete(StateEventAuditPersistenceInterface sea,
426
427                       SharkTransaction ti)
428
429       throws EventAuditException;
430
431
432
433    /**
434
435     * Method createAssignmentEventAudit
436
437     *
438
439     * @return an AssignmentEventAuditPersistenceInterface
440
441     */

442
443    public AssignmentEventAuditPersistenceInterface createAssignmentEventAudit();
444
445
446
447    /**
448
449     * Method createCreateProcessEventAudit
450
451     *
452
453     * @return a CreateProcessEventAuditPersistenceInterface
454
455     */

456
457    public CreateProcessEventAuditPersistenceInterface createCreateProcessEventAudit();
458
459
460
461    /**
462
463     * Method createDataEventAudit
464
465     *
466
467     * @return a DataEventAuditPersistenceInterface
468
469     */

470
471    public DataEventAuditPersistenceInterface createDataEventAudit();
472
473
474
475    /**
476
477     * Method createStateEventAudit
478
479     *
480
481     * @return a StateEventAuditPersistenceInterface
482
483     */

484
485    public StateEventAuditPersistenceInterface createStateEventAudit();
486
487
488
489    /**
490
491     * Method getNextId
492
493     *
494
495     * @param idName a String
496
497     *
498
499     * @return a String
500
501     *
502
503     * @exception EventAuditException on error.
504
505     */

506
507    public String JavaDoc getNextId(String JavaDoc idName) throws EventAuditException;
508
509 }
510
511
Popular Tags