001: package org.enhydra.shark.corba;
002:
003: import javax.transaction.UserTransaction;
004:
005: import org.omg.TimeBase.UtcT;
006: import org.omg.WfBase.BaseException;
007: import org.omg.WfBase.NameValue;
008: import org.omg.WorkflowModel.*;
009:
010: /**
011: * WfProcessImpl - Workflow Process Object implementation
012: *
013: * @author Sasa Bojanic
014: * @version 1.0
015: */
016: public class WfProcessCORBA extends _WfProcessImplBase {
017:
018: org.enhydra.shark.api.client.wfmodel.WfProcess sharkProc;
019:
020: private Collective __collective;
021:
022: /**
023: * Creates new WfProcessImpl
024: *
025: * @param sharkProc a WfProcess
026: */
027: protected WfProcessCORBA(Collective toJoin,
028: org.enhydra.shark.api.client.wfmodel.WfProcess sharkProc) {
029: __collective = toJoin;
030: toJoin.__recruit(this );
031: this .sharkProc = sharkProc;
032: }
033:
034: /**
035: * Retrieve the requestor of this process.
036: */
037: public WfRequester requester() throws BaseException {
038: UserTransaction ut = null;
039: boolean e = SharkCORBAServer.doesTransactionExist();
040: try {
041: ut = SharkCORBAUtilities.beginTransaction(e);
042: WfRequester req;
043: org.enhydra.shark.api.client.wfmodel.WfRequester requester = sharkProc
044: .requester();
045: if (requester instanceof org.enhydra.shark.api.client.wfmodel.WfActivity) {
046: req = new WfActivityCORBA(
047: __collective,
048: (org.enhydra.shark.api.client.wfmodel.WfActivity) requester);
049: } else if (requester instanceof WfLinkingRequesterForCORBA) {
050: req = WfLinkingRequesterForCORBA
051: .getCORBARequester(sharkProc.key());
052: } else {
053: req = new WfRequesterCORBA(__collective, requester);
054: }
055: SharkCORBAUtilities.commitTransaction(ut, e);
056: return req;
057: } catch (Exception ex) {
058: SharkCORBAUtilities.rollbackTransaction(ut, e);
059: throw new BaseException();
060: }
061: }
062:
063: /**
064: * Set the requester for this process.
065: */
066: public void set_requester(WfRequester new_value)
067: throws BaseException, CannotChangeRequester {
068: if (new_value == null)
069: throw new CannotChangeRequester(
070: "Trying to set external requester which is null!");
071:
072: if (new_value instanceof WfActivity) {
073: throw new CannotChangeRequester(
074: "Can't change requester to activity requester");
075: }
076:
077: UserTransaction ut = null;
078: boolean e = SharkCORBAServer.doesTransactionExist();
079: try {
080: ut = SharkCORBAUtilities.beginTransaction(e);
081: WfLinkingRequesterForCORBA lr = new WfLinkingRequesterForCORBA();
082: WfLinkingRequesterForCORBA.setCORBARequester(sharkProc
083: .key(), new_value);
084: sharkProc.set_requester(lr);
085: SharkCORBAUtilities.commitTransaction(ut, e);
086: } catch (org.enhydra.shark.api.client.wfmodel.CannotChangeRequester ccr) {
087: SharkCORBAUtilities.rollbackTransaction(ut, e);
088: throw new CannotChangeRequester();
089: } catch (Exception ex) {
090: SharkCORBAUtilities.rollbackTransaction(ut, e);
091: throw new BaseException();
092: }
093: }
094:
095: /**
096: * Retrieve the no of activities in this process.
097: */
098: public int how_many_step() throws BaseException {
099: UserTransaction ut = null;
100: boolean e = SharkCORBAServer.doesTransactionExist();
101: try {
102: ut = SharkCORBAUtilities.beginTransaction(e);
103: int ret = sharkProc.how_many_step();
104: SharkCORBAUtilities.commitTransaction(ut, e);
105: return ret;
106: } catch (Exception ex) {
107: SharkCORBAUtilities.rollbackTransaction(ut, e);
108: throw new BaseException();
109: }
110: }
111:
112: /**
113: * Retrieve the Iterator of active activities of this process.
114: */
115: public WfActivityIterator get_iterator_step() throws BaseException {
116: UserTransaction ut = null;
117: boolean e = SharkCORBAServer.doesTransactionExist();
118: try {
119: ut = SharkCORBAUtilities.beginTransaction(e);
120: WfActivityIterator ret = new WfActivityIteratorCORBA(
121: __collective, sharkProc.get_iterator_step());
122: SharkCORBAUtilities.commitTransaction(ut, e);
123: return ret;
124: } catch (Exception ex) {
125: SharkCORBAUtilities.rollbackTransaction(ut, e);
126: throw new BaseException();
127: }
128: }
129:
130: /**
131: * Retrieve the List of activities of this process.
132: *
133: * @param max_number High limit of elements in the result set (0->all).
134: */
135: public WfActivity[] get_sequence_step(int max_number)
136: throws BaseException {
137: UserTransaction ut = null;
138: boolean e = SharkCORBAServer.doesTransactionExist();
139: try {
140: ut = SharkCORBAUtilities.beginTransaction(e);
141: WfActivity[] ret = SharkCORBAUtilities.makeCORBAActivities(
142: __collective, sharkProc
143: .get_sequence_step(max_number));
144: SharkCORBAUtilities.commitTransaction(ut, e);
145: return ret;
146: } catch (Exception ex) {
147: SharkCORBAUtilities.rollbackTransaction(ut, e);
148: throw new BaseException();
149: }
150: }
151:
152: /**
153: * Check if some activity is a member of this process.
154: *
155: * @return true if the specific activity is a member of this process, false otherwise.
156: */
157: public boolean is_member_of_step(WfActivity member)
158: throws BaseException {
159: UserTransaction ut = null;
160: boolean e = SharkCORBAServer.doesTransactionExist();
161: try {
162: ut = SharkCORBAUtilities.beginTransaction(e);
163: WfActivity[] acts = get_sequence_step(0);
164: boolean ret = false;
165: if (acts != null) {
166: for (int i = 0; i < acts.length; i++) {
167: WfActivity act = acts[i];
168: if (act.key().equals(member.key())) {
169: ret = true;
170: break;
171: }
172: }
173: }
174: SharkCORBAUtilities.commitTransaction(ut, e);
175: return ret;
176: } catch (Exception ex) {
177: SharkCORBAUtilities.rollbackTransaction(ut, e);
178: throw new BaseException();
179: }
180: }
181:
182: /**
183: * Retrieve the WfProcessMgr of this process.
184: */
185: public WfProcessMgr manager() throws BaseException {
186: UserTransaction ut = null;
187: boolean e = SharkCORBAServer.doesTransactionExist();
188: try {
189: ut = SharkCORBAUtilities.beginTransaction(e);
190: WfProcessMgr ret = new WfProcessMgrCORBA(__collective,
191: sharkProc.manager());
192: SharkCORBAUtilities.commitTransaction(ut, e);
193: return ret;
194: } catch (Exception ex) {
195: SharkCORBAUtilities.rollbackTransaction(ut, e);
196: throw new BaseException();
197: }
198: }
199:
200: /**
201: * Retrieve the result for this process.
202: */
203: public NameValue[] result() throws BaseException,
204: ResultNotAvailable {
205: UserTransaction ut = null;
206: boolean e = SharkCORBAServer.doesTransactionExist();
207: try {
208: ut = SharkCORBAUtilities.beginTransaction(e);
209: NameValue[] ret = SharkCORBAUtilities
210: .makeCORBANameValueArray(this ._orb(), sharkProc
211: .result());
212: SharkCORBAUtilities.commitTransaction(ut, e);
213: return ret;
214: } catch (org.enhydra.shark.api.client.wfmodel.ResultNotAvailable rna) {
215: SharkCORBAUtilities.rollbackTransaction(ut, e);
216: throw new ResultNotAvailable();
217: } catch (Exception ex) {
218: SharkCORBAUtilities.rollbackTransaction(ut, e);
219: throw new BaseException();
220: }
221: }
222:
223: /**
224: * Starts the process - creates a separate thread.
225: */
226: public void start() throws BaseException, CannotStart,
227: AlreadyRunning {
228: UserTransaction ut = null;
229: boolean e = SharkCORBAServer.doesTransactionExist();
230: try {
231: ut = SharkCORBAUtilities.beginTransaction(e);
232: sharkProc.start();
233: SharkCORBAUtilities.commitTransaction(ut, e);
234: } catch (org.enhydra.shark.api.client.wfmodel.CannotStart cns) {
235: SharkCORBAUtilities.rollbackTransaction(ut, e);
236: throw new CannotStart();
237: } catch (org.enhydra.shark.api.client.wfmodel.AlreadyRunning ar) {
238: SharkCORBAUtilities.rollbackTransaction(ut, e);
239: throw new AlreadyRunning();
240: } catch (Exception ex) {
241: SharkCORBAUtilities.rollbackTransaction(ut, e);
242: throw new BaseException();
243: }
244: }
245:
246: /**
247: * Retrieve the iterator of activities in some specific state.
248: */
249: public WfActivityIterator get_activities_in_state(String state)
250: throws BaseException, InvalidState {
251: UserTransaction ut = null;
252: boolean e = SharkCORBAServer.doesTransactionExist();
253: try {
254: ut = SharkCORBAUtilities.beginTransaction(e);
255: WfActivityIterator ret = new WfActivityIteratorCORBA(
256: __collective, sharkProc
257: .get_activities_in_state(state));
258: SharkCORBAUtilities.commitTransaction(ut, e);
259: return ret;
260: } catch (org.enhydra.shark.api.client.wfmodel.InvalidState is) {
261: SharkCORBAUtilities.rollbackTransaction(ut, e);
262: throw new InvalidState();
263: } catch (Exception ex) {
264: SharkCORBAUtilities.rollbackTransaction(ut, e);
265: throw new BaseException();
266: }
267: }
268:
269: public workflow_stateType workflow_state() throws BaseException {
270: UserTransaction ut = null;
271: boolean e = SharkCORBAServer.doesTransactionExist();
272: try {
273: ut = SharkCORBAUtilities.beginTransaction(e);
274: workflow_stateType ret = workflow_stateType
275: .from_int(sharkProc.workflow_state().value());
276: SharkCORBAUtilities.commitTransaction(ut, e);
277: return ret;
278: } catch (Exception ex) {
279: SharkCORBAUtilities.rollbackTransaction(ut, e);
280: throw new BaseException();
281: }
282: }
283:
284: public while_openType while_open() throws BaseException {
285: UserTransaction ut = null;
286: boolean e = SharkCORBAServer.doesTransactionExist();
287: try {
288: ut = SharkCORBAUtilities.beginTransaction(e);
289: while_openType ret = while_openType.from_int(sharkProc
290: .while_open().value());
291: SharkCORBAUtilities.commitTransaction(ut, e);
292: return ret;
293: } catch (Exception ex) {
294: SharkCORBAUtilities.rollbackTransaction(ut, e);
295: throw new BaseException();
296: }
297: }
298:
299: public why_not_runningType why_not_running() throws BaseException {
300: UserTransaction ut = null;
301: boolean e = SharkCORBAServer.doesTransactionExist();
302: try {
303: ut = SharkCORBAUtilities.beginTransaction(e);
304: why_not_runningType ret = why_not_runningType
305: .from_int(sharkProc.why_not_running().value());
306: SharkCORBAUtilities.commitTransaction(ut, e);
307: return ret;
308: } catch (Exception ex) {
309: SharkCORBAUtilities.rollbackTransaction(ut, e);
310: throw new BaseException();
311: }
312: }
313:
314: public how_closedType how_closed() throws BaseException {
315: UserTransaction ut = null;
316: boolean e = SharkCORBAServer.doesTransactionExist();
317: try {
318: ut = SharkCORBAUtilities.beginTransaction(e);
319: how_closedType ret = how_closedType.from_int(sharkProc
320: .how_closed().value());
321: SharkCORBAUtilities.commitTransaction(ut, e);
322: return ret;
323: } catch (Exception ex) {
324: SharkCORBAUtilities.rollbackTransaction(ut, e);
325: throw new BaseException();
326: }
327: }
328:
329: public String[] valid_states() throws BaseException {
330: UserTransaction ut = null;
331: boolean e = SharkCORBAServer.doesTransactionExist();
332: try {
333: ut = SharkCORBAUtilities.beginTransaction(e);
334: String[] ret = sharkProc.valid_states();
335: SharkCORBAUtilities.commitTransaction(ut, e);
336: return ret;
337: } catch (Exception ex) {
338: SharkCORBAUtilities.rollbackTransaction(ut, e);
339: throw new BaseException();
340: }
341: }
342:
343: public String state() throws BaseException {
344: UserTransaction ut = null;
345: boolean e = SharkCORBAServer.doesTransactionExist();
346: try {
347: ut = SharkCORBAUtilities.beginTransaction(e);
348: String ret = sharkProc.state();
349: SharkCORBAUtilities.commitTransaction(ut, e);
350: return ret;
351: } catch (Exception ex) {
352: SharkCORBAUtilities.rollbackTransaction(ut, e);
353: throw new BaseException();
354: }
355: }
356:
357: public void change_state(String new_state) throws BaseException,
358: InvalidState, TransitionNotAllowed {
359: UserTransaction ut = null;
360: boolean e = SharkCORBAServer.doesTransactionExist();
361: try {
362: ut = SharkCORBAUtilities.beginTransaction(e);
363: sharkProc.change_state(new_state);
364: SharkCORBAUtilities.commitTransaction(ut, e);
365: } catch (org.enhydra.shark.api.client.wfmodel.InvalidState is) {
366: SharkCORBAUtilities.rollbackTransaction(ut, e);
367: throw new InvalidState();
368: } catch (org.enhydra.shark.api.client.wfmodel.TransitionNotAllowed tna) {
369: SharkCORBAUtilities.rollbackTransaction(ut, e);
370: throw new TransitionNotAllowed();
371: } catch (Exception ex) {
372: SharkCORBAUtilities.rollbackTransaction(ut, e);
373: throw new BaseException();
374: }
375: }
376:
377: public String name() throws BaseException {
378: UserTransaction ut = null;
379: boolean e = SharkCORBAServer.doesTransactionExist();
380: try {
381: ut = SharkCORBAUtilities.beginTransaction(e);
382: String ret = sharkProc.name();
383: SharkCORBAUtilities.commitTransaction(ut, e);
384: return ret;
385: } catch (Exception ex) {
386: SharkCORBAUtilities.rollbackTransaction(ut, e);
387: throw new BaseException();
388: }
389: }
390:
391: public void set_name(String new_value) throws BaseException {
392: UserTransaction ut = null;
393: boolean e = SharkCORBAServer.doesTransactionExist();
394: try {
395: ut = SharkCORBAUtilities.beginTransaction(e);
396: sharkProc.set_name(new_value);
397: SharkCORBAUtilities.commitTransaction(ut, e);
398: } catch (Exception ex) {
399: SharkCORBAUtilities.rollbackTransaction(ut, e);
400: throw new BaseException();
401: }
402: }
403:
404: public String key() throws BaseException {
405: UserTransaction ut = null;
406: boolean e = SharkCORBAServer.doesTransactionExist();
407: try {
408: ut = SharkCORBAUtilities.beginTransaction(e);
409: String ret = sharkProc.key();
410: SharkCORBAUtilities.commitTransaction(ut, e);
411: return ret;
412: } catch (Exception ex) {
413: SharkCORBAUtilities.rollbackTransaction(ut, e);
414: throw new BaseException();
415: }
416: }
417:
418: public String description() throws BaseException {
419: UserTransaction ut = null;
420: boolean e = SharkCORBAServer.doesTransactionExist();
421: try {
422: ut = SharkCORBAUtilities.beginTransaction(e);
423: String ret = sharkProc.description();
424: SharkCORBAUtilities.commitTransaction(ut, e);
425: return ret;
426: } catch (Exception ex) {
427: SharkCORBAUtilities.rollbackTransaction(ut, e);
428: throw new BaseException();
429: }
430: }
431:
432: public void set_description(String new_value) throws BaseException {
433: UserTransaction ut = null;
434: boolean e = SharkCORBAServer.doesTransactionExist();
435: try {
436: ut = SharkCORBAUtilities.beginTransaction(e);
437: sharkProc.set_description(new_value);
438: SharkCORBAUtilities.commitTransaction(ut, e);
439: } catch (Exception ex) {
440: SharkCORBAUtilities.rollbackTransaction(ut, e);
441: throw new BaseException();
442: }
443: }
444:
445: public NameValue[] process_context() throws BaseException {
446: UserTransaction ut = null;
447: boolean e = SharkCORBAServer.doesTransactionExist();
448: try {
449: ut = SharkCORBAUtilities.beginTransaction(e);
450: NameValue[] ret = SharkCORBAUtilities
451: .makeCORBANameValueArray(this ._orb(), sharkProc
452: .process_context());
453: SharkCORBAUtilities.commitTransaction(ut, e);
454: return ret;
455: } catch (Exception ex) {
456: SharkCORBAUtilities.rollbackTransaction(ut, e);
457: throw new BaseException();
458: }
459: }
460:
461: public void set_process_context(NameValue[] new_value)
462: throws BaseException, InvalidData, UpdateNotAllowed {
463:
464: UserTransaction ut = null;
465: boolean e = SharkCORBAServer.doesTransactionExist();
466: try {
467: ut = SharkCORBAUtilities.beginTransaction(e);
468: sharkProc.set_process_context(SharkCORBAUtilities
469: .makeMap(new_value));
470: SharkCORBAUtilities.commitTransaction(ut, e);
471: } catch (org.enhydra.shark.api.client.wfmodel.InvalidData id) {
472: SharkCORBAUtilities.rollbackTransaction(ut, e);
473: throw new InvalidData();
474: } catch (org.enhydra.shark.api.client.wfmodel.UpdateNotAllowed una) {
475: SharkCORBAUtilities.rollbackTransaction(ut, e);
476: throw new UpdateNotAllowed();
477: } catch (Exception ex) {
478: SharkCORBAUtilities.rollbackTransaction(ut, e);
479: throw new BaseException();
480: }
481: }
482:
483: public short priority() throws BaseException {
484: UserTransaction ut = null;
485: boolean e = SharkCORBAServer.doesTransactionExist();
486: try {
487: ut = SharkCORBAUtilities.beginTransaction(e);
488: short ret = sharkProc.priority();
489: SharkCORBAUtilities.commitTransaction(ut, e);
490: return ret;
491: } catch (Exception ex) {
492: SharkCORBAUtilities.rollbackTransaction(ut, e);
493: throw new BaseException();
494: }
495: }
496:
497: public void set_priority(short new_value) throws BaseException {
498: UserTransaction ut = null;
499: boolean e = SharkCORBAServer.doesTransactionExist();
500: try {
501: ut = SharkCORBAUtilities.beginTransaction(e);
502: sharkProc.set_priority(new_value);
503: SharkCORBAUtilities.commitTransaction(ut, e);
504: } catch (Exception ex) {
505: SharkCORBAUtilities.rollbackTransaction(ut, e);
506: throw new BaseException();
507: }
508: }
509:
510: /**
511: * Resume this process.
512: */
513: public void resume() throws BaseException, CannotResume,
514: NotSuspended {
515: UserTransaction ut = null;
516: boolean e = SharkCORBAServer.doesTransactionExist();
517: try {
518: ut = SharkCORBAUtilities.beginTransaction(e);
519: sharkProc.resume();
520: SharkCORBAUtilities.commitTransaction(ut, e);
521: } catch (org.enhydra.shark.api.client.wfmodel.CannotResume cnr) {
522: SharkCORBAUtilities.rollbackTransaction(ut, e);
523: throw new CannotResume();
524: } catch (org.enhydra.shark.api.client.wfmodel.NotSuspended ns) {
525: SharkCORBAUtilities.rollbackTransaction(ut, e);
526: throw new NotSuspended();
527: } catch (Exception ex) {
528: SharkCORBAUtilities.rollbackTransaction(ut, e);
529: throw new BaseException();
530: }
531: }
532:
533: /**
534: * Suspend this process.
535: */
536: public void suspend() throws BaseException, CannotSuspend,
537: NotRunning, AlreadySuspended {
538: UserTransaction ut = null;
539: boolean e = SharkCORBAServer.doesTransactionExist();
540: try {
541: ut = SharkCORBAUtilities.beginTransaction(e);
542: sharkProc.suspend();
543: SharkCORBAUtilities.commitTransaction(ut, e);
544: } catch (org.enhydra.shark.api.client.wfmodel.CannotSuspend cns) {
545: SharkCORBAUtilities.rollbackTransaction(ut, e);
546: throw new CannotSuspend();
547: } catch (org.enhydra.shark.api.client.wfmodel.NotRunning nr) {
548: SharkCORBAUtilities.rollbackTransaction(ut, e);
549: throw new NotRunning();
550: } catch (org.enhydra.shark.api.client.wfmodel.AlreadySuspended as) {
551: SharkCORBAUtilities.rollbackTransaction(ut, e);
552: throw new AlreadySuspended();
553: } catch (Exception ex) {
554: SharkCORBAUtilities.rollbackTransaction(ut, e);
555: throw new BaseException();
556: }
557: }
558:
559: /**
560: * Terminate this process.
561: */
562: public synchronized void terminate() throws BaseException,
563: CannotStop, NotRunning {
564: UserTransaction ut = null;
565: boolean e = SharkCORBAServer.doesTransactionExist();
566: try {
567: ut = SharkCORBAUtilities.beginTransaction(e);
568: sharkProc.terminate();
569: SharkCORBAUtilities.commitTransaction(ut, e);
570: } catch (org.enhydra.shark.api.client.wfmodel.CannotStop cns) {
571: SharkCORBAUtilities.rollbackTransaction(ut, e);
572: throw new CannotStop();
573: } catch (org.enhydra.shark.api.client.wfmodel.NotRunning nr) {
574: SharkCORBAUtilities.rollbackTransaction(ut, e);
575: throw new NotRunning();
576: } catch (Exception ex) {
577: SharkCORBAUtilities.rollbackTransaction(ut, e);
578: throw new BaseException();
579: }
580: }
581:
582: /**
583: * Abort the execution of this process.
584: */
585: public synchronized void abort() throws BaseException, CannotStop,
586: NotRunning {
587: UserTransaction ut = null;
588: boolean e = SharkCORBAServer.doesTransactionExist();
589: try {
590: ut = SharkCORBAUtilities.beginTransaction(e);
591: sharkProc.abort();
592: SharkCORBAUtilities.commitTransaction(ut, e);
593: } catch (org.enhydra.shark.api.client.wfmodel.CannotStop cns) {
594: SharkCORBAUtilities.rollbackTransaction(ut, e);
595: throw new CannotStop();
596: } catch (org.enhydra.shark.api.client.wfmodel.NotRunning nr) {
597: SharkCORBAUtilities.rollbackTransaction(ut, e);
598: throw new NotRunning();
599: } catch (Exception ex) {
600: SharkCORBAUtilities.rollbackTransaction(ut, e);
601: throw new BaseException();
602: }
603: }
604:
605: public int how_many_history() throws BaseException,
606: HistoryNotAvailable {
607: UserTransaction ut = null;
608: boolean e = SharkCORBAServer.doesTransactionExist();
609: try {
610: ut = SharkCORBAUtilities.beginTransaction(e);
611: int ret = sharkProc.how_many_history();
612: SharkCORBAUtilities.commitTransaction(ut, e);
613: return ret;
614: } catch (org.enhydra.shark.api.client.wfmodel.HistoryNotAvailable hna) {
615: SharkCORBAUtilities.rollbackTransaction(ut, e);
616: throw new HistoryNotAvailable();
617: } catch (Exception ex) {
618: SharkCORBAUtilities.rollbackTransaction(ut, e);
619: throw new BaseException();
620: }
621: }
622:
623: /**
624: * Search in the history for specific elements.
625: *
626: * @return Found history elements that meet the search criteria.
627: */
628: public WfEventAuditIterator get_iterator_history(String query,
629: NameValue[] names_in_query) throws BaseException,
630: HistoryNotAvailable {
631: UserTransaction ut = null;
632: boolean e = SharkCORBAServer.doesTransactionExist();
633: try {
634: ut = SharkCORBAUtilities.beginTransaction(e);
635: WfEventAuditIterator ret = new WfEventAuditIteratorCORBA(
636: __collective, sharkProc
637: .get_iterator_history(query,
638: SharkCORBAUtilities
639: .makeMap(names_in_query)));
640: SharkCORBAUtilities.commitTransaction(ut, e);
641: return ret;
642: } catch (org.enhydra.shark.api.client.wfmodel.HistoryNotAvailable hna) {
643: SharkCORBAUtilities.rollbackTransaction(ut, e);
644: throw new HistoryNotAvailable();
645: } catch (Exception ex) {
646: SharkCORBAUtilities.rollbackTransaction(ut, e);
647: throw new BaseException();
648: }
649: }
650:
651: /**
652: * Getter for history sequence.
653: *
654: * @return List of History objects.
655: */
656: public WfEventAudit[] get_sequence_history(int max_number)
657: throws BaseException, HistoryNotAvailable {
658: UserTransaction ut = null;
659: boolean e = SharkCORBAServer.doesTransactionExist();
660: try {
661: ut = SharkCORBAUtilities.beginTransaction(e);
662: WfEventAudit[] ret = SharkCORBAUtilities
663: .makeCORBAEventAudits(__collective, sharkProc
664: .get_sequence_history(max_number));
665: SharkCORBAUtilities.commitTransaction(ut, e);
666: return ret;
667: } catch (org.enhydra.shark.api.client.wfmodel.HistoryNotAvailable hna) {
668: SharkCORBAUtilities.rollbackTransaction(ut, e);
669: throw new HistoryNotAvailable();
670: } catch (Exception ex) {
671: SharkCORBAUtilities.rollbackTransaction(ut, e);
672: throw new BaseException();
673: }
674: }
675:
676: /**
677: * Checks if a 'member' is an element of the history.
678: *
679: * @return true if the element of the history, false otherwise.
680: */
681: public boolean is_member_of_history(WfExecutionObject member)
682: throws BaseException {
683: UserTransaction ut = null;
684: boolean e = SharkCORBAServer.doesTransactionExist();
685: try {
686: ut = SharkCORBAUtilities.beginTransaction(e);
687: boolean ret = false;
688: WfEventAudit[] evs = SharkCORBAUtilities
689: .makeCORBAEventAudits(__collective, sharkProc
690: .get_sequence_history(0));
691: if (evs != null) {
692: for (int i = 0; i < evs.length; i++) {
693: WfEventAudit ea = evs[i];
694: if (member instanceof WfActivity) {
695: WfActivity act = (WfActivity) member;
696: if (act.container().key().equals(
697: ea.process_key())
698: && act.key().equals(ea.activity_key())) {
699: ret = true;
700: break;
701: }
702: } else {
703: if (member.key().equals(ea.process_key())) {
704: ret = true;
705: break;
706: }
707: }
708: }
709: }
710: SharkCORBAUtilities.commitTransaction(ut, e);
711: return ret;
712: } catch (Exception ex) {
713: SharkCORBAUtilities.rollbackTransaction(ut, e);
714: throw new BaseException();
715: }
716: }
717:
718: public UtcT last_state_time() throws BaseException {
719: UserTransaction ut = null;
720: boolean e = SharkCORBAServer.doesTransactionExist();
721: try {
722: ut = SharkCORBAUtilities.beginTransaction(e);
723: org.enhydra.shark.api.client.timebase.UtcT t = sharkProc
724: .last_state_time();
725: UtcT ret = new UtcT(t.time, t.inacclo, t.inacchi, t.tdf);
726: SharkCORBAUtilities.commitTransaction(ut, e);
727: return ret;
728: } catch (Exception ex) {
729: SharkCORBAUtilities.rollbackTransaction(ut, e);
730: throw new BaseException();
731: }
732: }
733:
734: /**
735: * It is assumed that there can't be two or more processes having the same key.
736: */
737: public boolean equals(java.lang.Object obj) {
738: if (!(obj instanceof WfProcess))
739: return false;
740: WfProcess proc = (WfProcess) obj;
741: UserTransaction ut = null;
742: boolean e = SharkCORBAServer.doesTransactionExist();
743: try {
744: boolean ret = proc.key().equals(key());
745: SharkCORBAUtilities.commitTransaction(ut, e);
746: return ret;
747: } catch (Exception ex) {
748: SharkCORBAUtilities.rollbackTransaction(ut, e);
749: return false;
750: }
751: }
752:
753: public String toString() {
754: return sharkProc.toString();
755: }
756: }
|