001: package org.enhydra.shark.corba;
002:
003: import javax.transaction.UserTransaction;
004:
005: import org.omg.WfBase.BaseException;
006: import org.omg.WfBase.NameValueInfo;
007: import org.omg.WorkflowModel.*;
008:
009: /**
010: * WfProcessMgrImpl - Workflow Process Manager implementation
011: */
012:
013: public class WfProcessMgrCORBA extends _WfProcessMgrImplBase {
014:
015: org.enhydra.shark.api.client.wfmodel.WfProcessMgr sharkProcMgr;
016:
017: private Collective __collective;
018:
019: /**
020: * Creates new WfProcessMgrImpl
021: *
022: * @param sharkProcMgr a WfProcessMgr
023: */
024: protected WfProcessMgrCORBA(
025: Collective toJoin,
026: org.enhydra.shark.api.client.wfmodel.WfProcessMgr sharkProcMgr) {
027: __collective = toJoin;
028: toJoin.__recruit(this );
029: this .sharkProcMgr = sharkProcMgr;
030: }
031:
032: public int how_many_process() throws BaseException {
033: UserTransaction ut = null;
034: boolean e = SharkCORBAServer.doesTransactionExist();
035: try {
036: ut = SharkCORBAUtilities.beginTransaction(e);
037: int ret = sharkProcMgr.how_many_process();
038: SharkCORBAUtilities.commitTransaction(ut, e);
039: return ret;
040: } catch (Exception ex) {
041: SharkCORBAUtilities.rollbackTransaction(ut, e);
042: throw new BaseException();
043: }
044: }
045:
046: public WfProcessIterator get_iterator_process()
047: throws BaseException {
048: UserTransaction ut = null;
049: boolean e = SharkCORBAServer.doesTransactionExist();
050: try {
051: ut = SharkCORBAUtilities.beginTransaction(e);
052: WfProcessIterator ret = new WfProcessIteratorCORBA(
053: __collective, sharkProcMgr.get_iterator_process());
054: SharkCORBAUtilities.commitTransaction(ut, e);
055: return ret;
056: } catch (Exception ex) {
057: SharkCORBAUtilities.rollbackTransaction(ut, e);
058: throw new BaseException();
059: }
060: }
061:
062: public WfProcess[] get_sequence_process(int max_number)
063: throws BaseException {
064: UserTransaction ut = null;
065: boolean e = SharkCORBAServer.doesTransactionExist();
066: try {
067: ut = SharkCORBAUtilities.beginTransaction(e);
068: WfProcess[] ret = SharkCORBAUtilities.makeCORBAProcesses(
069: __collective, sharkProcMgr
070: .get_sequence_process(max_number));
071: SharkCORBAUtilities.commitTransaction(ut, e);
072: return ret;
073: } catch (Exception ex) {
074: SharkCORBAUtilities.rollbackTransaction(ut, e);
075: throw new BaseException();
076: }
077: }
078:
079: public boolean is_member_of_process(WfProcess member)
080: throws BaseException {
081: UserTransaction ut = null;
082: boolean e = SharkCORBAServer.doesTransactionExist();
083: try {
084: ut = SharkCORBAUtilities.beginTransaction(e);
085: WfProcess[] procs = get_sequence_process(0);
086: boolean ret = false;
087: if (procs != null) {
088: for (int i = 0; i < procs.length; i++) {
089: if (procs[i].key().equals(member.key())) {
090: ret = true;
091: break;
092: }
093: }
094: }
095: SharkCORBAUtilities.commitTransaction(ut, e);
096: return ret;
097: } catch (Exception ex) {
098: SharkCORBAUtilities.rollbackTransaction(ut, e);
099: throw new BaseException();
100: }
101: }
102:
103: public process_mgr_stateType process_mgr_state()
104: throws BaseException {
105: UserTransaction ut = null;
106: boolean e = SharkCORBAServer.doesTransactionExist();
107: try {
108: ut = SharkCORBAUtilities.beginTransaction(e);
109: process_mgr_stateType ret = process_mgr_stateType
110: .from_int(sharkProcMgr.process_mgr_state().value());
111: SharkCORBAUtilities.commitTransaction(ut, e);
112: return ret;
113: } catch (Exception ex) {
114: SharkCORBAUtilities.rollbackTransaction(ut, e);
115: throw new BaseException();
116: }
117: }
118:
119: public void set_process_mgr_state(process_mgr_stateType new_state)
120: throws BaseException, TransitionNotAllowed {
121: UserTransaction ut = null;
122: boolean e = SharkCORBAServer.doesTransactionExist();
123: try {
124: ut = SharkCORBAUtilities.beginTransaction(e);
125: sharkProcMgr
126: .set_process_mgr_state(org.enhydra.shark.api.client.wfmodel.process_mgr_stateType
127: .from_int(new_state.value()));
128: SharkCORBAUtilities.commitTransaction(ut, e);
129: } catch (org.enhydra.shark.api.client.wfmodel.TransitionNotAllowed tna) {
130: SharkCORBAUtilities.rollbackTransaction(ut, e);
131: throw new TransitionNotAllowed();
132: } catch (Exception ex) {
133: SharkCORBAUtilities.rollbackTransaction(ut, e);
134: throw new BaseException();
135: }
136: }
137:
138: public String name() throws BaseException {
139: UserTransaction ut = null;
140: boolean e = SharkCORBAServer.doesTransactionExist();
141: try {
142: ut = SharkCORBAUtilities.beginTransaction(e);
143: String ret = sharkProcMgr.name();
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: public String description() throws BaseException {
153: UserTransaction ut = null;
154: boolean e = SharkCORBAServer.doesTransactionExist();
155: try {
156: ut = SharkCORBAUtilities.beginTransaction(e);
157: String ret = sharkProcMgr.description();
158: SharkCORBAUtilities.commitTransaction(ut, e);
159: return ret;
160: } catch (Exception ex) {
161: SharkCORBAUtilities.rollbackTransaction(ut, e);
162: throw new BaseException();
163: }
164: }
165:
166: public String category() throws BaseException {
167: UserTransaction ut = null;
168: boolean e = SharkCORBAServer.doesTransactionExist();
169: try {
170: ut = SharkCORBAUtilities.beginTransaction(e);
171: String ret = sharkProcMgr.category();
172: SharkCORBAUtilities.commitTransaction(ut, e);
173: return ret;
174: } catch (Exception ex) {
175: SharkCORBAUtilities.rollbackTransaction(ut, e);
176: throw new BaseException();
177: }
178: }
179:
180: public String version() throws BaseException {
181: UserTransaction ut = null;
182: boolean e = SharkCORBAServer.doesTransactionExist();
183: try {
184: ut = SharkCORBAUtilities.beginTransaction(e);
185: String ret = sharkProcMgr.version();
186: SharkCORBAUtilities.commitTransaction(ut, e);
187: return ret;
188: } catch (Exception ex) {
189: SharkCORBAUtilities.rollbackTransaction(ut, e);
190: throw new BaseException();
191: }
192: }
193:
194: public NameValueInfo[] context_signature() throws BaseException {
195: UserTransaction ut = null;
196: boolean e = SharkCORBAServer.doesTransactionExist();
197: try {
198: ut = SharkCORBAUtilities.beginTransaction(e);
199: NameValueInfo[] ret = SharkCORBAUtilities
200: .makeCORBANameValueInfoArray(sharkProcMgr
201: .context_signature());
202: SharkCORBAUtilities.commitTransaction(ut, e);
203: return ret;
204: } catch (Exception ex) {
205: SharkCORBAUtilities.rollbackTransaction(ut, e);
206: throw new BaseException();
207: }
208: }
209:
210: public NameValueInfo[] result_signature() throws BaseException {
211: UserTransaction ut = null;
212: boolean e = SharkCORBAServer.doesTransactionExist();
213: try {
214: ut = SharkCORBAUtilities.beginTransaction(e);
215: NameValueInfo[] ret = SharkCORBAUtilities
216: .makeCORBANameValueInfoArray(sharkProcMgr
217: .result_signature());
218: SharkCORBAUtilities.commitTransaction(ut, e);
219: return ret;
220: } catch (Exception ex) {
221: SharkCORBAUtilities.rollbackTransaction(ut, e);
222: throw new BaseException();
223: }
224: }
225:
226: /**
227: * Create a WfProcess object
228: */
229: public WfProcess create_process(WfRequester requester)
230: throws BaseException, NotEnabled, InvalidRequester,
231: RequesterRequired {
232:
233: if (requester == null)
234: throw new RequesterRequired();
235:
236: if (requester instanceof WfActivity) {
237: throw new BaseException();
238: }
239:
240: UserTransaction ut = null;
241: boolean e = SharkCORBAServer.doesTransactionExist();
242: try {
243: ut = SharkCORBAUtilities.beginTransaction(e);
244: WfLinkingRequesterForCORBA lr = new WfLinkingRequesterForCORBA();
245: org.enhydra.shark.api.client.wfmodel.WfProcess procInternal = sharkProcMgr
246: .create_process(lr);
247: WfLinkingRequesterForCORBA.setCORBARequester(procInternal
248: .key(), requester);
249: WfProcess ret = new WfProcessCORBA(__collective,
250: procInternal);
251: SharkCORBAUtilities.commitTransaction(ut, e);
252: return ret;
253: } catch (org.enhydra.shark.api.client.wfmodel.NotEnabled ne) {
254: SharkCORBAUtilities.rollbackTransaction(ut, e);
255: throw new NotEnabled();
256: } catch (org.enhydra.shark.api.client.wfmodel.InvalidRequester ir) {
257: SharkCORBAUtilities.rollbackTransaction(ut, e);
258: throw new InvalidRequester();
259: } catch (org.enhydra.shark.api.client.wfmodel.RequesterRequired rr) {
260: SharkCORBAUtilities.rollbackTransaction(ut, e);
261: throw new RequesterRequired();
262: } catch (Exception ex) {
263: SharkCORBAUtilities.rollbackTransaction(ut, e);
264: throw new BaseException();
265: }
266: }
267:
268: /**
269: * It is assumed that there can't be two or more processes mgrs having the same name.
270: */
271: public boolean equals(Object obj) {
272: if (!(obj instanceof WfProcessMgr))
273: return false;
274: WfProcessMgr mgr = (WfProcessMgr) obj;
275: UserTransaction ut = null;
276: boolean e = SharkCORBAServer.doesTransactionExist();
277: try {
278: ut = SharkCORBAUtilities.beginTransaction(e);
279: boolean ret = mgr.name().equals(name());
280: SharkCORBAUtilities.commitTransaction(ut, e);
281: return ret;
282: } catch (Exception ex) {
283: SharkCORBAUtilities.rollbackTransaction(ut, e);
284: return false;
285: }
286: }
287:
288: public String toString() {
289: return sharkProcMgr.toString();
290: }
291:
292: }
|