00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 package cast.interfaces;
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 public final class _WorkingMemoryDelM extends Ice._ObjectDelM implements _WorkingMemoryDel
00024 {
00025 public void
00026 beat(java.util.Map<String, String> __ctx)
00027 throws IceInternal.LocalExceptionWrapper
00028 {
00029 IceInternal.Outgoing __og = __handler.getOutgoing("beat", Ice.OperationMode.Idempotent, __ctx);
00030 try
00031 {
00032 boolean __ok = __og.invoke();
00033 if(!__og.is().isEmpty())
00034 {
00035 try
00036 {
00037 if(!__ok)
00038 {
00039 try
00040 {
00041 __og.throwUserException();
00042 }
00043 catch(Ice.UserException __ex)
00044 {
00045 throw new Ice.UnknownUserException(__ex.ice_name());
00046 }
00047 }
00048 __og.is().skipEmptyEncaps();
00049 }
00050 catch(Ice.LocalException __ex)
00051 {
00052 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00053 }
00054 }
00055 }
00056 finally
00057 {
00058 __handler.reclaimOutgoing(__og);
00059 }
00060 }
00061
00062 public void
00063 configure(java.util.Map<java.lang.String, java.lang.String> config, java.util.Map<String, String> __ctx)
00064 throws IceInternal.LocalExceptionWrapper
00065 {
00066 IceInternal.Outgoing __og = __handler.getOutgoing("configure", Ice.OperationMode.Normal, __ctx);
00067 try
00068 {
00069 try
00070 {
00071 IceInternal.BasicStream __os = __og.os();
00072 cast.cdl.StringMapHelper.write(__os, config);
00073 }
00074 catch(Ice.LocalException __ex)
00075 {
00076 __og.abort(__ex);
00077 }
00078 boolean __ok = __og.invoke();
00079 if(!__og.is().isEmpty())
00080 {
00081 try
00082 {
00083 if(!__ok)
00084 {
00085 try
00086 {
00087 __og.throwUserException();
00088 }
00089 catch(Ice.UserException __ex)
00090 {
00091 throw new Ice.UnknownUserException(__ex.ice_name());
00092 }
00093 }
00094 __og.is().skipEmptyEncaps();
00095 }
00096 catch(Ice.LocalException __ex)
00097 {
00098 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00099 }
00100 }
00101 }
00102 finally
00103 {
00104 __handler.reclaimOutgoing(__og);
00105 }
00106 }
00107
00108 public void
00109 destroy(java.util.Map<String, String> __ctx)
00110 throws IceInternal.LocalExceptionWrapper
00111 {
00112 IceInternal.Outgoing __og = __handler.getOutgoing("destroy", Ice.OperationMode.Normal, __ctx);
00113 try
00114 {
00115 boolean __ok = __og.invoke();
00116 if(!__og.is().isEmpty())
00117 {
00118 try
00119 {
00120 if(!__ok)
00121 {
00122 try
00123 {
00124 __og.throwUserException();
00125 }
00126 catch(Ice.UserException __ex)
00127 {
00128 throw new Ice.UnknownUserException(__ex.ice_name());
00129 }
00130 }
00131 __og.is().skipEmptyEncaps();
00132 }
00133 catch(Ice.LocalException __ex)
00134 {
00135 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00136 }
00137 }
00138 }
00139 finally
00140 {
00141 __handler.reclaimOutgoing(__og);
00142 }
00143 }
00144
00145 public String
00146 getID(java.util.Map<String, String> __ctx)
00147 throws IceInternal.LocalExceptionWrapper
00148 {
00149 IceInternal.Outgoing __og = __handler.getOutgoing("getID", Ice.OperationMode.Idempotent, __ctx);
00150 try
00151 {
00152 boolean __ok = __og.invoke();
00153 try
00154 {
00155 if(!__ok)
00156 {
00157 try
00158 {
00159 __og.throwUserException();
00160 }
00161 catch(Ice.UserException __ex)
00162 {
00163 throw new Ice.UnknownUserException(__ex.ice_name());
00164 }
00165 }
00166 IceInternal.BasicStream __is = __og.is();
00167 __is.startReadEncaps();
00168 String __ret;
00169 __ret = __is.readString();
00170 __is.endReadEncaps();
00171 return __ret;
00172 }
00173 catch(Ice.LocalException __ex)
00174 {
00175 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00176 }
00177 }
00178 finally
00179 {
00180 __handler.reclaimOutgoing(__og);
00181 }
00182 }
00183
00184 public void
00185 run(java.util.Map<String, String> __ctx)
00186 throws IceInternal.LocalExceptionWrapper
00187 {
00188 IceInternal.Outgoing __og = __handler.getOutgoing("run", Ice.OperationMode.Normal, __ctx);
00189 try
00190 {
00191 boolean __ok = __og.invoke();
00192 if(!__og.is().isEmpty())
00193 {
00194 try
00195 {
00196 if(!__ok)
00197 {
00198 try
00199 {
00200 __og.throwUserException();
00201 }
00202 catch(Ice.UserException __ex)
00203 {
00204 throw new Ice.UnknownUserException(__ex.ice_name());
00205 }
00206 }
00207 __og.is().skipEmptyEncaps();
00208 }
00209 catch(Ice.LocalException __ex)
00210 {
00211 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00212 }
00213 }
00214 }
00215 finally
00216 {
00217 __handler.reclaimOutgoing(__og);
00218 }
00219 }
00220
00221 public void
00222 setComponentManager(ComponentManagerPrx man, java.util.Map<String, String> __ctx)
00223 throws IceInternal.LocalExceptionWrapper
00224 {
00225 IceInternal.Outgoing __og = __handler.getOutgoing("setComponentManager", Ice.OperationMode.Normal, __ctx);
00226 try
00227 {
00228 try
00229 {
00230 IceInternal.BasicStream __os = __og.os();
00231 ComponentManagerPrxHelper.__write(__os, man);
00232 }
00233 catch(Ice.LocalException __ex)
00234 {
00235 __og.abort(__ex);
00236 }
00237 boolean __ok = __og.invoke();
00238 if(!__og.is().isEmpty())
00239 {
00240 try
00241 {
00242 if(!__ok)
00243 {
00244 try
00245 {
00246 __og.throwUserException();
00247 }
00248 catch(Ice.UserException __ex)
00249 {
00250 throw new Ice.UnknownUserException(__ex.ice_name());
00251 }
00252 }
00253 __og.is().skipEmptyEncaps();
00254 }
00255 catch(Ice.LocalException __ex)
00256 {
00257 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00258 }
00259 }
00260 }
00261 finally
00262 {
00263 __handler.reclaimOutgoing(__og);
00264 }
00265 }
00266
00267 public void
00268 setID(String id, java.util.Map<String, String> __ctx)
00269 throws IceInternal.LocalExceptionWrapper
00270 {
00271 IceInternal.Outgoing __og = __handler.getOutgoing("setID", Ice.OperationMode.Normal, __ctx);
00272 try
00273 {
00274 try
00275 {
00276 IceInternal.BasicStream __os = __og.os();
00277 __os.writeString(id);
00278 }
00279 catch(Ice.LocalException __ex)
00280 {
00281 __og.abort(__ex);
00282 }
00283 boolean __ok = __og.invoke();
00284 if(!__og.is().isEmpty())
00285 {
00286 try
00287 {
00288 if(!__ok)
00289 {
00290 try
00291 {
00292 __og.throwUserException();
00293 }
00294 catch(Ice.UserException __ex)
00295 {
00296 throw new Ice.UnknownUserException(__ex.ice_name());
00297 }
00298 }
00299 __og.is().skipEmptyEncaps();
00300 }
00301 catch(Ice.LocalException __ex)
00302 {
00303 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00304 }
00305 }
00306 }
00307 finally
00308 {
00309 __handler.reclaimOutgoing(__og);
00310 }
00311 }
00312
00313 public void
00314 setTimeServer(TimeServerPrx ts, java.util.Map<String, String> __ctx)
00315 throws IceInternal.LocalExceptionWrapper
00316 {
00317 IceInternal.Outgoing __og = __handler.getOutgoing("setTimeServer", Ice.OperationMode.Normal, __ctx);
00318 try
00319 {
00320 try
00321 {
00322 IceInternal.BasicStream __os = __og.os();
00323 TimeServerPrxHelper.__write(__os, ts);
00324 }
00325 catch(Ice.LocalException __ex)
00326 {
00327 __og.abort(__ex);
00328 }
00329 boolean __ok = __og.invoke();
00330 if(!__og.is().isEmpty())
00331 {
00332 try
00333 {
00334 if(!__ok)
00335 {
00336 try
00337 {
00338 __og.throwUserException();
00339 }
00340 catch(Ice.UserException __ex)
00341 {
00342 throw new Ice.UnknownUserException(__ex.ice_name());
00343 }
00344 }
00345 __og.is().skipEmptyEncaps();
00346 }
00347 catch(Ice.LocalException __ex)
00348 {
00349 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00350 }
00351 }
00352 }
00353 finally
00354 {
00355 __handler.reclaimOutgoing(__og);
00356 }
00357 }
00358
00359 public void
00360 start(java.util.Map<String, String> __ctx)
00361 throws IceInternal.LocalExceptionWrapper
00362 {
00363 IceInternal.Outgoing __og = __handler.getOutgoing("start", Ice.OperationMode.Normal, __ctx);
00364 try
00365 {
00366 boolean __ok = __og.invoke();
00367 if(!__og.is().isEmpty())
00368 {
00369 try
00370 {
00371 if(!__ok)
00372 {
00373 try
00374 {
00375 __og.throwUserException();
00376 }
00377 catch(Ice.UserException __ex)
00378 {
00379 throw new Ice.UnknownUserException(__ex.ice_name());
00380 }
00381 }
00382 __og.is().skipEmptyEncaps();
00383 }
00384 catch(Ice.LocalException __ex)
00385 {
00386 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00387 }
00388 }
00389 }
00390 finally
00391 {
00392 __handler.reclaimOutgoing(__og);
00393 }
00394 }
00395
00396 public void
00397 stop(java.util.Map<String, String> __ctx)
00398 throws IceInternal.LocalExceptionWrapper
00399 {
00400 IceInternal.Outgoing __og = __handler.getOutgoing("stop", Ice.OperationMode.Normal, __ctx);
00401 try
00402 {
00403 boolean __ok = __og.invoke();
00404 if(!__og.is().isEmpty())
00405 {
00406 try
00407 {
00408 if(!__ok)
00409 {
00410 try
00411 {
00412 __og.throwUserException();
00413 }
00414 catch(Ice.UserException __ex)
00415 {
00416 throw new Ice.UnknownUserException(__ex.ice_name());
00417 }
00418 }
00419 __og.is().skipEmptyEncaps();
00420 }
00421 catch(Ice.LocalException __ex)
00422 {
00423 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00424 }
00425 }
00426 }
00427 finally
00428 {
00429 __handler.reclaimOutgoing(__og);
00430 }
00431 }
00432
00433 public void
00434 addReader(WorkingMemoryReaderComponentPrx reader, java.util.Map<String, String> __ctx)
00435 throws IceInternal.LocalExceptionWrapper
00436 {
00437 IceInternal.Outgoing __og = __handler.getOutgoing("addReader", Ice.OperationMode.Normal, __ctx);
00438 try
00439 {
00440 try
00441 {
00442 IceInternal.BasicStream __os = __og.os();
00443 WorkingMemoryReaderComponentPrxHelper.__write(__os, reader);
00444 }
00445 catch(Ice.LocalException __ex)
00446 {
00447 __og.abort(__ex);
00448 }
00449 boolean __ok = __og.invoke();
00450 if(!__og.is().isEmpty())
00451 {
00452 try
00453 {
00454 if(!__ok)
00455 {
00456 try
00457 {
00458 __og.throwUserException();
00459 }
00460 catch(Ice.UserException __ex)
00461 {
00462 throw new Ice.UnknownUserException(__ex.ice_name());
00463 }
00464 }
00465 __og.is().skipEmptyEncaps();
00466 }
00467 catch(Ice.LocalException __ex)
00468 {
00469 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00470 }
00471 }
00472 }
00473 finally
00474 {
00475 __handler.reclaimOutgoing(__og);
00476 }
00477 }
00478
00479 public void
00480 addToWorkingMemory(String id, String subarch, String type, String component, Ice.Object entry, java.util.Map<String, String> __ctx)
00481 throws IceInternal.LocalExceptionWrapper,
00482 cast.AlreadyExistsOnWMException,
00483 cast.UnknownSubarchitectureException
00484 {
00485 IceInternal.Outgoing __og = __handler.getOutgoing("addToWorkingMemory", Ice.OperationMode.Normal, __ctx);
00486 try
00487 {
00488 try
00489 {
00490 IceInternal.BasicStream __os = __og.os();
00491 __os.writeString(id);
00492 __os.writeString(subarch);
00493 __os.writeString(type);
00494 __os.writeString(component);
00495 __os.writeObject(entry);
00496 __os.writePendingObjects();
00497 }
00498 catch(Ice.LocalException __ex)
00499 {
00500 __og.abort(__ex);
00501 }
00502 boolean __ok = __og.invoke();
00503 try
00504 {
00505 if(!__ok)
00506 {
00507 try
00508 {
00509 __og.throwUserException();
00510 }
00511 catch(cast.AlreadyExistsOnWMException __ex)
00512 {
00513 throw __ex;
00514 }
00515 catch(cast.UnknownSubarchitectureException __ex)
00516 {
00517 throw __ex;
00518 }
00519 catch(Ice.UserException __ex)
00520 {
00521 throw new Ice.UnknownUserException(__ex.ice_name());
00522 }
00523 }
00524 __og.is().skipEmptyEncaps();
00525 }
00526 catch(Ice.LocalException __ex)
00527 {
00528 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00529 }
00530 }
00531 finally
00532 {
00533 __handler.reclaimOutgoing(__og);
00534 }
00535 }
00536
00537 public void
00538 deleteFromWorkingMemory(String id, String subarch, String component, java.util.Map<String, String> __ctx)
00539 throws IceInternal.LocalExceptionWrapper,
00540 cast.DoesNotExistOnWMException,
00541 cast.UnknownSubarchitectureException
00542 {
00543 IceInternal.Outgoing __og = __handler.getOutgoing("deleteFromWorkingMemory", Ice.OperationMode.Normal, __ctx);
00544 try
00545 {
00546 try
00547 {
00548 IceInternal.BasicStream __os = __og.os();
00549 __os.writeString(id);
00550 __os.writeString(subarch);
00551 __os.writeString(component);
00552 }
00553 catch(Ice.LocalException __ex)
00554 {
00555 __og.abort(__ex);
00556 }
00557 boolean __ok = __og.invoke();
00558 try
00559 {
00560 if(!__ok)
00561 {
00562 try
00563 {
00564 __og.throwUserException();
00565 }
00566 catch(cast.DoesNotExistOnWMException __ex)
00567 {
00568 throw __ex;
00569 }
00570 catch(cast.UnknownSubarchitectureException __ex)
00571 {
00572 throw __ex;
00573 }
00574 catch(Ice.UserException __ex)
00575 {
00576 throw new Ice.UnknownUserException(__ex.ice_name());
00577 }
00578 }
00579 __og.is().skipEmptyEncaps();
00580 }
00581 catch(Ice.LocalException __ex)
00582 {
00583 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00584 }
00585 }
00586 finally
00587 {
00588 __handler.reclaimOutgoing(__og);
00589 }
00590 }
00591
00592 public boolean
00593 exists(String id, String subarch, java.util.Map<String, String> __ctx)
00594 throws IceInternal.LocalExceptionWrapper,
00595 cast.UnknownSubarchitectureException
00596 {
00597 IceInternal.Outgoing __og = __handler.getOutgoing("exists", Ice.OperationMode.Idempotent, __ctx);
00598 try
00599 {
00600 try
00601 {
00602 IceInternal.BasicStream __os = __og.os();
00603 __os.writeString(id);
00604 __os.writeString(subarch);
00605 }
00606 catch(Ice.LocalException __ex)
00607 {
00608 __og.abort(__ex);
00609 }
00610 boolean __ok = __og.invoke();
00611 try
00612 {
00613 if(!__ok)
00614 {
00615 try
00616 {
00617 __og.throwUserException();
00618 }
00619 catch(cast.UnknownSubarchitectureException __ex)
00620 {
00621 throw __ex;
00622 }
00623 catch(Ice.UserException __ex)
00624 {
00625 throw new Ice.UnknownUserException(__ex.ice_name());
00626 }
00627 }
00628 IceInternal.BasicStream __is = __og.is();
00629 __is.startReadEncaps();
00630 boolean __ret;
00631 __ret = __is.readBool();
00632 __is.endReadEncaps();
00633 return __ret;
00634 }
00635 catch(Ice.LocalException __ex)
00636 {
00637 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00638 }
00639 }
00640 finally
00641 {
00642 __handler.reclaimOutgoing(__og);
00643 }
00644 }
00645
00646 public cast.cdl.WorkingMemoryPermissions
00647 getPermissions(String id, String subarch, java.util.Map<String, String> __ctx)
00648 throws IceInternal.LocalExceptionWrapper,
00649 cast.DoesNotExistOnWMException,
00650 cast.UnknownSubarchitectureException
00651 {
00652 IceInternal.Outgoing __og = __handler.getOutgoing("getPermissions", Ice.OperationMode.Idempotent, __ctx);
00653 try
00654 {
00655 try
00656 {
00657 IceInternal.BasicStream __os = __og.os();
00658 __os.writeString(id);
00659 __os.writeString(subarch);
00660 }
00661 catch(Ice.LocalException __ex)
00662 {
00663 __og.abort(__ex);
00664 }
00665 boolean __ok = __og.invoke();
00666 try
00667 {
00668 if(!__ok)
00669 {
00670 try
00671 {
00672 __og.throwUserException();
00673 }
00674 catch(cast.DoesNotExistOnWMException __ex)
00675 {
00676 throw __ex;
00677 }
00678 catch(cast.UnknownSubarchitectureException __ex)
00679 {
00680 throw __ex;
00681 }
00682 catch(Ice.UserException __ex)
00683 {
00684 throw new Ice.UnknownUserException(__ex.ice_name());
00685 }
00686 }
00687 IceInternal.BasicStream __is = __og.is();
00688 __is.startReadEncaps();
00689 cast.cdl.WorkingMemoryPermissions __ret;
00690 __ret = cast.cdl.WorkingMemoryPermissions.__read(__is);
00691 __is.endReadEncaps();
00692 return __ret;
00693 }
00694 catch(Ice.LocalException __ex)
00695 {
00696 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00697 }
00698 }
00699 finally
00700 {
00701 __handler.reclaimOutgoing(__og);
00702 }
00703 }
00704
00705 public int
00706 getVersionNumber(String id, String subarch, java.util.Map<String, String> __ctx)
00707 throws IceInternal.LocalExceptionWrapper,
00708 cast.DoesNotExistOnWMException,
00709 cast.UnknownSubarchitectureException
00710 {
00711 IceInternal.Outgoing __og = __handler.getOutgoing("getVersionNumber", Ice.OperationMode.Idempotent, __ctx);
00712 try
00713 {
00714 try
00715 {
00716 IceInternal.BasicStream __os = __og.os();
00717 __os.writeString(id);
00718 __os.writeString(subarch);
00719 }
00720 catch(Ice.LocalException __ex)
00721 {
00722 __og.abort(__ex);
00723 }
00724 boolean __ok = __og.invoke();
00725 try
00726 {
00727 if(!__ok)
00728 {
00729 try
00730 {
00731 __og.throwUserException();
00732 }
00733 catch(cast.DoesNotExistOnWMException __ex)
00734 {
00735 throw __ex;
00736 }
00737 catch(cast.UnknownSubarchitectureException __ex)
00738 {
00739 throw __ex;
00740 }
00741 catch(Ice.UserException __ex)
00742 {
00743 throw new Ice.UnknownUserException(__ex.ice_name());
00744 }
00745 }
00746 IceInternal.BasicStream __is = __og.is();
00747 __is.startReadEncaps();
00748 int __ret;
00749 __ret = __is.readInt();
00750 __is.endReadEncaps();
00751 return __ret;
00752 }
00753 catch(Ice.LocalException __ex)
00754 {
00755 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00756 }
00757 }
00758 finally
00759 {
00760 __handler.reclaimOutgoing(__og);
00761 }
00762 }
00763
00764 public void
00765 getWorkingMemoryEntries(String type, String subarch, int count, String component, cast.cdl.WorkingMemoryEntrySeqHolder entries, java.util.Map<String, String> __ctx)
00766 throws IceInternal.LocalExceptionWrapper,
00767 cast.UnknownSubarchitectureException
00768 {
00769 IceInternal.Outgoing __og = __handler.getOutgoing("getWorkingMemoryEntries", Ice.OperationMode.Normal, __ctx);
00770 try
00771 {
00772 try
00773 {
00774 IceInternal.BasicStream __os = __og.os();
00775 __os.writeString(type);
00776 __os.writeString(subarch);
00777 __os.writeInt(count);
00778 __os.writeString(component);
00779 }
00780 catch(Ice.LocalException __ex)
00781 {
00782 __og.abort(__ex);
00783 }
00784 boolean __ok = __og.invoke();
00785 try
00786 {
00787 if(!__ok)
00788 {
00789 try
00790 {
00791 __og.throwUserException();
00792 }
00793 catch(cast.UnknownSubarchitectureException __ex)
00794 {
00795 throw __ex;
00796 }
00797 catch(Ice.UserException __ex)
00798 {
00799 throw new Ice.UnknownUserException(__ex.ice_name());
00800 }
00801 }
00802 IceInternal.BasicStream __is = __og.is();
00803 __is.startReadEncaps();
00804 entries.value = cast.cdl.WorkingMemoryEntrySeqHelper.read(__is);
00805 __is.readPendingObjects();
00806 __is.endReadEncaps();
00807 }
00808 catch(Ice.LocalException __ex)
00809 {
00810 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00811 }
00812 }
00813 finally
00814 {
00815 __handler.reclaimOutgoing(__og);
00816 }
00817 }
00818
00819 public cast.cdl.WorkingMemoryEntry
00820 getWorkingMemoryEntry(String id, String subarch, String component, java.util.Map<String, String> __ctx)
00821 throws IceInternal.LocalExceptionWrapper,
00822 cast.DoesNotExistOnWMException,
00823 cast.UnknownSubarchitectureException
00824 {
00825 IceInternal.Outgoing __og = __handler.getOutgoing("getWorkingMemoryEntry", Ice.OperationMode.Normal, __ctx);
00826 try
00827 {
00828 try
00829 {
00830 IceInternal.BasicStream __os = __og.os();
00831 __os.writeString(id);
00832 __os.writeString(subarch);
00833 __os.writeString(component);
00834 }
00835 catch(Ice.LocalException __ex)
00836 {
00837 __og.abort(__ex);
00838 }
00839 boolean __ok = __og.invoke();
00840 try
00841 {
00842 if(!__ok)
00843 {
00844 try
00845 {
00846 __og.throwUserException();
00847 }
00848 catch(cast.DoesNotExistOnWMException __ex)
00849 {
00850 throw __ex;
00851 }
00852 catch(cast.UnknownSubarchitectureException __ex)
00853 {
00854 throw __ex;
00855 }
00856 catch(Ice.UserException __ex)
00857 {
00858 throw new Ice.UnknownUserException(__ex.ice_name());
00859 }
00860 }
00861 IceInternal.BasicStream __is = __og.is();
00862 __is.startReadEncaps();
00863 cast.cdl.WorkingMemoryEntryHolder __ret = new cast.cdl.WorkingMemoryEntryHolder();
00864 __is.readObject(__ret);
00865 __is.readPendingObjects();
00866 __is.endReadEncaps();
00867 return __ret.value;
00868 }
00869 catch(Ice.LocalException __ex)
00870 {
00871 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00872 }
00873 }
00874 finally
00875 {
00876 __handler.reclaimOutgoing(__og);
00877 }
00878 }
00879
00880 public void
00881 lockEntry(String id, String subarch, String component, cast.cdl.WorkingMemoryPermissions permissions, java.util.Map<String, String> __ctx)
00882 throws IceInternal.LocalExceptionWrapper,
00883 cast.DoesNotExistOnWMException,
00884 cast.UnknownSubarchitectureException
00885 {
00886 IceInternal.Outgoing __og = __handler.getOutgoing("lockEntry", Ice.OperationMode.Normal, __ctx);
00887 try
00888 {
00889 try
00890 {
00891 IceInternal.BasicStream __os = __og.os();
00892 __os.writeString(id);
00893 __os.writeString(subarch);
00894 __os.writeString(component);
00895 permissions.__write(__os);
00896 }
00897 catch(Ice.LocalException __ex)
00898 {
00899 __og.abort(__ex);
00900 }
00901 boolean __ok = __og.invoke();
00902 try
00903 {
00904 if(!__ok)
00905 {
00906 try
00907 {
00908 __og.throwUserException();
00909 }
00910 catch(cast.DoesNotExistOnWMException __ex)
00911 {
00912 throw __ex;
00913 }
00914 catch(cast.UnknownSubarchitectureException __ex)
00915 {
00916 throw __ex;
00917 }
00918 catch(Ice.UserException __ex)
00919 {
00920 throw new Ice.UnknownUserException(__ex.ice_name());
00921 }
00922 }
00923 __og.is().skipEmptyEncaps();
00924 }
00925 catch(Ice.LocalException __ex)
00926 {
00927 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00928 }
00929 }
00930 finally
00931 {
00932 __handler.reclaimOutgoing(__og);
00933 }
00934 }
00935
00936 public void
00937 overwriteWorkingMemory(String id, String subarch, String type, String component, Ice.Object entry, java.util.Map<String, String> __ctx)
00938 throws IceInternal.LocalExceptionWrapper,
00939 cast.DoesNotExistOnWMException,
00940 cast.UnknownSubarchitectureException
00941 {
00942 IceInternal.Outgoing __og = __handler.getOutgoing("overwriteWorkingMemory", Ice.OperationMode.Normal, __ctx);
00943 try
00944 {
00945 try
00946 {
00947 IceInternal.BasicStream __os = __og.os();
00948 __os.writeString(id);
00949 __os.writeString(subarch);
00950 __os.writeString(type);
00951 __os.writeString(component);
00952 __os.writeObject(entry);
00953 __os.writePendingObjects();
00954 }
00955 catch(Ice.LocalException __ex)
00956 {
00957 __og.abort(__ex);
00958 }
00959 boolean __ok = __og.invoke();
00960 try
00961 {
00962 if(!__ok)
00963 {
00964 try
00965 {
00966 __og.throwUserException();
00967 }
00968 catch(cast.DoesNotExistOnWMException __ex)
00969 {
00970 throw __ex;
00971 }
00972 catch(cast.UnknownSubarchitectureException __ex)
00973 {
00974 throw __ex;
00975 }
00976 catch(Ice.UserException __ex)
00977 {
00978 throw new Ice.UnknownUserException(__ex.ice_name());
00979 }
00980 }
00981 __og.is().skipEmptyEncaps();
00982 }
00983 catch(Ice.LocalException __ex)
00984 {
00985 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00986 }
00987 }
00988 finally
00989 {
00990 __handler.reclaimOutgoing(__og);
00991 }
00992 }
00993
00994 public void
00995 receiveChangeEvent(cast.cdl.WorkingMemoryChange wmc, java.util.Map<String, String> __ctx)
00996 throws IceInternal.LocalExceptionWrapper
00997 {
00998 IceInternal.Outgoing __og = __handler.getOutgoing("receiveChangeEvent", Ice.OperationMode.Normal, __ctx);
00999 try
01000 {
01001 try
01002 {
01003 IceInternal.BasicStream __os = __og.os();
01004 wmc.__write(__os);
01005 }
01006 catch(Ice.LocalException __ex)
01007 {
01008 __og.abort(__ex);
01009 }
01010 boolean __ok = __og.invoke();
01011 if(!__og.is().isEmpty())
01012 {
01013 try
01014 {
01015 if(!__ok)
01016 {
01017 try
01018 {
01019 __og.throwUserException();
01020 }
01021 catch(Ice.UserException __ex)
01022 {
01023 throw new Ice.UnknownUserException(__ex.ice_name());
01024 }
01025 }
01026 __og.is().skipEmptyEncaps();
01027 }
01028 catch(Ice.LocalException __ex)
01029 {
01030 throw new IceInternal.LocalExceptionWrapper(__ex, false);
01031 }
01032 }
01033 }
01034 finally
01035 {
01036 __handler.reclaimOutgoing(__og);
01037 }
01038 }
01039
01040 public void
01041 registerComponentFilter(cast.cdl.WorkingMemoryChangeFilter filter, int priority, java.util.Map<String, String> __ctx)
01042 throws IceInternal.LocalExceptionWrapper
01043 {
01044 IceInternal.Outgoing __og = __handler.getOutgoing("registerComponentFilter", Ice.OperationMode.Normal, __ctx);
01045 try
01046 {
01047 try
01048 {
01049 IceInternal.BasicStream __os = __og.os();
01050 filter.__write(__os);
01051 __os.writeInt(priority);
01052 }
01053 catch(Ice.LocalException __ex)
01054 {
01055 __og.abort(__ex);
01056 }
01057 boolean __ok = __og.invoke();
01058 if(!__og.is().isEmpty())
01059 {
01060 try
01061 {
01062 if(!__ok)
01063 {
01064 try
01065 {
01066 __og.throwUserException();
01067 }
01068 catch(Ice.UserException __ex)
01069 {
01070 throw new Ice.UnknownUserException(__ex.ice_name());
01071 }
01072 }
01073 __og.is().skipEmptyEncaps();
01074 }
01075 catch(Ice.LocalException __ex)
01076 {
01077 throw new IceInternal.LocalExceptionWrapper(__ex, false);
01078 }
01079 }
01080 }
01081 finally
01082 {
01083 __handler.reclaimOutgoing(__og);
01084 }
01085 }
01086
01087 public void
01088 registerWorkingMemoryFilter(cast.cdl.WorkingMemoryChangeFilter filter, String subarch, int priority, java.util.Map<String, String> __ctx)
01089 throws IceInternal.LocalExceptionWrapper
01090 {
01091 IceInternal.Outgoing __og = __handler.getOutgoing("registerWorkingMemoryFilter", Ice.OperationMode.Normal, __ctx);
01092 try
01093 {
01094 try
01095 {
01096 IceInternal.BasicStream __os = __og.os();
01097 filter.__write(__os);
01098 __os.writeString(subarch);
01099 __os.writeInt(priority);
01100 }
01101 catch(Ice.LocalException __ex)
01102 {
01103 __og.abort(__ex);
01104 }
01105 boolean __ok = __og.invoke();
01106 if(!__og.is().isEmpty())
01107 {
01108 try
01109 {
01110 if(!__ok)
01111 {
01112 try
01113 {
01114 __og.throwUserException();
01115 }
01116 catch(Ice.UserException __ex)
01117 {
01118 throw new Ice.UnknownUserException(__ex.ice_name());
01119 }
01120 }
01121 __og.is().skipEmptyEncaps();
01122 }
01123 catch(Ice.LocalException __ex)
01124 {
01125 throw new IceInternal.LocalExceptionWrapper(__ex, false);
01126 }
01127 }
01128 }
01129 finally
01130 {
01131 __handler.reclaimOutgoing(__og);
01132 }
01133 }
01134
01135 public void
01136 removeComponentFilter(cast.cdl.WorkingMemoryChangeFilter filter, java.util.Map<String, String> __ctx)
01137 throws IceInternal.LocalExceptionWrapper
01138 {
01139 IceInternal.Outgoing __og = __handler.getOutgoing("removeComponentFilter", Ice.OperationMode.Normal, __ctx);
01140 try
01141 {
01142 try
01143 {
01144 IceInternal.BasicStream __os = __og.os();
01145 filter.__write(__os);
01146 }
01147 catch(Ice.LocalException __ex)
01148 {
01149 __og.abort(__ex);
01150 }
01151 boolean __ok = __og.invoke();
01152 if(!__og.is().isEmpty())
01153 {
01154 try
01155 {
01156 if(!__ok)
01157 {
01158 try
01159 {
01160 __og.throwUserException();
01161 }
01162 catch(Ice.UserException __ex)
01163 {
01164 throw new Ice.UnknownUserException(__ex.ice_name());
01165 }
01166 }
01167 __og.is().skipEmptyEncaps();
01168 }
01169 catch(Ice.LocalException __ex)
01170 {
01171 throw new IceInternal.LocalExceptionWrapper(__ex, false);
01172 }
01173 }
01174 }
01175 finally
01176 {
01177 __handler.reclaimOutgoing(__og);
01178 }
01179 }
01180
01181 public void
01182 removeWorkingMemoryFilter(cast.cdl.WorkingMemoryChangeFilter filter, java.util.Map<String, String> __ctx)
01183 throws IceInternal.LocalExceptionWrapper
01184 {
01185 IceInternal.Outgoing __og = __handler.getOutgoing("removeWorkingMemoryFilter", Ice.OperationMode.Normal, __ctx);
01186 try
01187 {
01188 try
01189 {
01190 IceInternal.BasicStream __os = __og.os();
01191 filter.__write(__os);
01192 }
01193 catch(Ice.LocalException __ex)
01194 {
01195 __og.abort(__ex);
01196 }
01197 boolean __ok = __og.invoke();
01198 if(!__og.is().isEmpty())
01199 {
01200 try
01201 {
01202 if(!__ok)
01203 {
01204 try
01205 {
01206 __og.throwUserException();
01207 }
01208 catch(Ice.UserException __ex)
01209 {
01210 throw new Ice.UnknownUserException(__ex.ice_name());
01211 }
01212 }
01213 __og.is().skipEmptyEncaps();
01214 }
01215 catch(Ice.LocalException __ex)
01216 {
01217 throw new IceInternal.LocalExceptionWrapper(__ex, false);
01218 }
01219 }
01220 }
01221 finally
01222 {
01223 __handler.reclaimOutgoing(__og);
01224 }
01225 }
01226
01227 public void
01228 setWorkingMemory(WorkingMemoryPrx wm, String subarch, java.util.Map<String, String> __ctx)
01229 throws IceInternal.LocalExceptionWrapper
01230 {
01231 IceInternal.Outgoing __og = __handler.getOutgoing("setWorkingMemory", Ice.OperationMode.Normal, __ctx);
01232 try
01233 {
01234 try
01235 {
01236 IceInternal.BasicStream __os = __og.os();
01237 WorkingMemoryPrxHelper.__write(__os, wm);
01238 __os.writeString(subarch);
01239 }
01240 catch(Ice.LocalException __ex)
01241 {
01242 __og.abort(__ex);
01243 }
01244 boolean __ok = __og.invoke();
01245 if(!__og.is().isEmpty())
01246 {
01247 try
01248 {
01249 if(!__ok)
01250 {
01251 try
01252 {
01253 __og.throwUserException();
01254 }
01255 catch(Ice.UserException __ex)
01256 {
01257 throw new Ice.UnknownUserException(__ex.ice_name());
01258 }
01259 }
01260 __og.is().skipEmptyEncaps();
01261 }
01262 catch(Ice.LocalException __ex)
01263 {
01264 throw new IceInternal.LocalExceptionWrapper(__ex, false);
01265 }
01266 }
01267 }
01268 finally
01269 {
01270 __handler.reclaimOutgoing(__og);
01271 }
01272 }
01273
01274 public boolean
01275 tryLockEntry(String id, String subarch, String component, cast.cdl.WorkingMemoryPermissions permissions, java.util.Map<String, String> __ctx)
01276 throws IceInternal.LocalExceptionWrapper,
01277 cast.DoesNotExistOnWMException,
01278 cast.UnknownSubarchitectureException
01279 {
01280 IceInternal.Outgoing __og = __handler.getOutgoing("tryLockEntry", Ice.OperationMode.Normal, __ctx);
01281 try
01282 {
01283 try
01284 {
01285 IceInternal.BasicStream __os = __og.os();
01286 __os.writeString(id);
01287 __os.writeString(subarch);
01288 __os.writeString(component);
01289 permissions.__write(__os);
01290 }
01291 catch(Ice.LocalException __ex)
01292 {
01293 __og.abort(__ex);
01294 }
01295 boolean __ok = __og.invoke();
01296 try
01297 {
01298 if(!__ok)
01299 {
01300 try
01301 {
01302 __og.throwUserException();
01303 }
01304 catch(cast.DoesNotExistOnWMException __ex)
01305 {
01306 throw __ex;
01307 }
01308 catch(cast.UnknownSubarchitectureException __ex)
01309 {
01310 throw __ex;
01311 }
01312 catch(Ice.UserException __ex)
01313 {
01314 throw new Ice.UnknownUserException(__ex.ice_name());
01315 }
01316 }
01317 IceInternal.BasicStream __is = __og.is();
01318 __is.startReadEncaps();
01319 boolean __ret;
01320 __ret = __is.readBool();
01321 __is.endReadEncaps();
01322 return __ret;
01323 }
01324 catch(Ice.LocalException __ex)
01325 {
01326 throw new IceInternal.LocalExceptionWrapper(__ex, false);
01327 }
01328 }
01329 finally
01330 {
01331 __handler.reclaimOutgoing(__og);
01332 }
01333 }
01334
01335 public void
01336 unlockEntry(String id, String subarch, String component, java.util.Map<String, String> __ctx)
01337 throws IceInternal.LocalExceptionWrapper,
01338 cast.ConsistencyException,
01339 cast.DoesNotExistOnWMException,
01340 cast.UnknownSubarchitectureException
01341 {
01342 IceInternal.Outgoing __og = __handler.getOutgoing("unlockEntry", Ice.OperationMode.Normal, __ctx);
01343 try
01344 {
01345 try
01346 {
01347 IceInternal.BasicStream __os = __og.os();
01348 __os.writeString(id);
01349 __os.writeString(subarch);
01350 __os.writeString(component);
01351 }
01352 catch(Ice.LocalException __ex)
01353 {
01354 __og.abort(__ex);
01355 }
01356 boolean __ok = __og.invoke();
01357 try
01358 {
01359 if(!__ok)
01360 {
01361 try
01362 {
01363 __og.throwUserException();
01364 }
01365 catch(cast.ConsistencyException __ex)
01366 {
01367 throw __ex;
01368 }
01369 catch(cast.DoesNotExistOnWMException __ex)
01370 {
01371 throw __ex;
01372 }
01373 catch(cast.UnknownSubarchitectureException __ex)
01374 {
01375 throw __ex;
01376 }
01377 catch(Ice.UserException __ex)
01378 {
01379 throw new Ice.UnknownUserException(__ex.ice_name());
01380 }
01381 }
01382 __og.is().skipEmptyEncaps();
01383 }
01384 catch(Ice.LocalException __ex)
01385 {
01386 throw new IceInternal.LocalExceptionWrapper(__ex, false);
01387 }
01388 }
01389 finally
01390 {
01391 __handler.reclaimOutgoing(__og);
01392 }
01393 }
01394 }
