CAST Java: /Users/nah/Documents/code/cast/src/java/cast/interfaces/_WorkingMemoryReaderComponentDelD.java Source File

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2010 ZeroC, Inc. All rights reserved.
00004 //
00005 // This copy of Ice is licensed to you under the terms described in the
00006 // ICE_LICENSE file included in this distribution.
00007 //
00008 // **********************************************************************
00009 
00010 // Ice version 3.4.1
00011 
00012 package cast.interfaces;
00013 
00014 // <auto-generated>
00015 //
00016 // Generated from file `CDL.ice'
00017 //
00018 // Warning: do not edit this file.
00019 //
00020 // </auto-generated>
00021 
00022 
00023 public final class _WorkingMemoryReaderComponentDelD extends Ice._ObjectDelD implements _WorkingMemoryReaderComponentDel
00024 {
00025     public void
00026     beat(java.util.Map<String, String> __ctx)
00027         throws IceInternal.LocalExceptionWrapper
00028     {
00029         final Ice.Current __current = new Ice.Current();
00030         __initCurrent(__current, "beat", Ice.OperationMode.Idempotent, __ctx);
00031         IceInternal.Direct __direct = null;
00032         try
00033         {
00034             __direct = new IceInternal.Direct(__current)
00035             {
00036                 public Ice.DispatchStatus run(Ice.Object __obj)
00037                 {
00038                     WorkingMemoryReaderComponent __servant = null;
00039                     try
00040                     {
00041                         __servant = (WorkingMemoryReaderComponent)__obj;
00042                     }
00043                     catch(ClassCastException __ex)
00044                     {
00045                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00046                     }
00047                     __servant.beat(__current);
00048                     return Ice.DispatchStatus.DispatchOK;
00049                 }
00050             };
00051             try
00052             {
00053                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00054                 if(__status == Ice.DispatchStatus.DispatchUserException)
00055                 {
00056                     __direct.throwUserException();
00057                 }
00058                 assert __status == Ice.DispatchStatus.DispatchOK;
00059             }
00060             finally
00061             {
00062                 __direct.destroy();
00063             }
00064         }
00065         catch(Ice.SystemException __ex)
00066         {
00067             throw __ex;
00068         }
00069         catch(java.lang.Throwable __ex)
00070         {
00071             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00072         }
00073     }
00074 
00075     public void
00076     configure(final java.util.Map<java.lang.String, java.lang.String> config, java.util.Map<String, String> __ctx)
00077         throws IceInternal.LocalExceptionWrapper
00078     {
00079         final Ice.Current __current = new Ice.Current();
00080         __initCurrent(__current, "configure", Ice.OperationMode.Normal, __ctx);
00081         IceInternal.Direct __direct = null;
00082         try
00083         {
00084             __direct = new IceInternal.Direct(__current)
00085             {
00086                 public Ice.DispatchStatus run(Ice.Object __obj)
00087                 {
00088                     WorkingMemoryReaderComponent __servant = null;
00089                     try
00090                     {
00091                         __servant = (WorkingMemoryReaderComponent)__obj;
00092                     }
00093                     catch(ClassCastException __ex)
00094                     {
00095                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00096                     }
00097                     __servant.configure(config, __current);
00098                     return Ice.DispatchStatus.DispatchOK;
00099                 }
00100             };
00101             try
00102             {
00103                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00104                 if(__status == Ice.DispatchStatus.DispatchUserException)
00105                 {
00106                     __direct.throwUserException();
00107                 }
00108                 assert __status == Ice.DispatchStatus.DispatchOK;
00109             }
00110             finally
00111             {
00112                 __direct.destroy();
00113             }
00114         }
00115         catch(Ice.SystemException __ex)
00116         {
00117             throw __ex;
00118         }
00119         catch(java.lang.Throwable __ex)
00120         {
00121             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00122         }
00123     }
00124 
00125     public void
00126     destroy(java.util.Map<String, String> __ctx)
00127         throws IceInternal.LocalExceptionWrapper
00128     {
00129         final Ice.Current __current = new Ice.Current();
00130         __initCurrent(__current, "destroy", Ice.OperationMode.Normal, __ctx);
00131         IceInternal.Direct __direct = null;
00132         try
00133         {
00134             __direct = new IceInternal.Direct(__current)
00135             {
00136                 public Ice.DispatchStatus run(Ice.Object __obj)
00137                 {
00138                     WorkingMemoryReaderComponent __servant = null;
00139                     try
00140                     {
00141                         __servant = (WorkingMemoryReaderComponent)__obj;
00142                     }
00143                     catch(ClassCastException __ex)
00144                     {
00145                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00146                     }
00147                     __servant.destroy(__current);
00148                     return Ice.DispatchStatus.DispatchOK;
00149                 }
00150             };
00151             try
00152             {
00153                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00154                 if(__status == Ice.DispatchStatus.DispatchUserException)
00155                 {
00156                     __direct.throwUserException();
00157                 }
00158                 assert __status == Ice.DispatchStatus.DispatchOK;
00159             }
00160             finally
00161             {
00162                 __direct.destroy();
00163             }
00164         }
00165         catch(Ice.SystemException __ex)
00166         {
00167             throw __ex;
00168         }
00169         catch(java.lang.Throwable __ex)
00170         {
00171             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00172         }
00173     }
00174 
00175     public String
00176     getID(java.util.Map<String, String> __ctx)
00177         throws IceInternal.LocalExceptionWrapper
00178     {
00179         final Ice.Current __current = new Ice.Current();
00180         __initCurrent(__current, "getID", Ice.OperationMode.Idempotent, __ctx);
00181         final Ice.StringHolder __result = new Ice.StringHolder();
00182         IceInternal.Direct __direct = null;
00183         try
00184         {
00185             __direct = new IceInternal.Direct(__current)
00186             {
00187                 public Ice.DispatchStatus run(Ice.Object __obj)
00188                 {
00189                     WorkingMemoryReaderComponent __servant = null;
00190                     try
00191                     {
00192                         __servant = (WorkingMemoryReaderComponent)__obj;
00193                     }
00194                     catch(ClassCastException __ex)
00195                     {
00196                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00197                     }
00198                     __result.value = __servant.getID(__current);
00199                     return Ice.DispatchStatus.DispatchOK;
00200                 }
00201             };
00202             try
00203             {
00204                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00205                 if(__status == Ice.DispatchStatus.DispatchUserException)
00206                 {
00207                     __direct.throwUserException();
00208                 }
00209                 assert __status == Ice.DispatchStatus.DispatchOK;
00210                 return __result.value;
00211             }
00212             finally
00213             {
00214                 __direct.destroy();
00215             }
00216         }
00217         catch(Ice.SystemException __ex)
00218         {
00219             throw __ex;
00220         }
00221         catch(java.lang.Throwable __ex)
00222         {
00223             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00224         }
00225         return __result.value;
00226     }
00227 
00228     public void
00229     run(java.util.Map<String, String> __ctx)
00230         throws IceInternal.LocalExceptionWrapper
00231     {
00232         final Ice.Current __current = new Ice.Current();
00233         __initCurrent(__current, "run", Ice.OperationMode.Normal, __ctx);
00234         IceInternal.Direct __direct = null;
00235         try
00236         {
00237             __direct = new IceInternal.Direct(__current)
00238             {
00239                 public Ice.DispatchStatus run(Ice.Object __obj)
00240                 {
00241                     WorkingMemoryReaderComponent __servant = null;
00242                     try
00243                     {
00244                         __servant = (WorkingMemoryReaderComponent)__obj;
00245                     }
00246                     catch(ClassCastException __ex)
00247                     {
00248                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00249                     }
00250                     __servant.run(__current);
00251                     return Ice.DispatchStatus.DispatchOK;
00252                 }
00253             };
00254             try
00255             {
00256                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00257                 if(__status == Ice.DispatchStatus.DispatchUserException)
00258                 {
00259                     __direct.throwUserException();
00260                 }
00261                 assert __status == Ice.DispatchStatus.DispatchOK;
00262             }
00263             finally
00264             {
00265                 __direct.destroy();
00266             }
00267         }
00268         catch(Ice.SystemException __ex)
00269         {
00270             throw __ex;
00271         }
00272         catch(java.lang.Throwable __ex)
00273         {
00274             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00275         }
00276     }
00277 
00278     public void
00279     setComponentManager(final ComponentManagerPrx man, java.util.Map<String, String> __ctx)
00280         throws IceInternal.LocalExceptionWrapper
00281     {
00282         final Ice.Current __current = new Ice.Current();
00283         __initCurrent(__current, "setComponentManager", Ice.OperationMode.Normal, __ctx);
00284         IceInternal.Direct __direct = null;
00285         try
00286         {
00287             __direct = new IceInternal.Direct(__current)
00288             {
00289                 public Ice.DispatchStatus run(Ice.Object __obj)
00290                 {
00291                     WorkingMemoryReaderComponent __servant = null;
00292                     try
00293                     {
00294                         __servant = (WorkingMemoryReaderComponent)__obj;
00295                     }
00296                     catch(ClassCastException __ex)
00297                     {
00298                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00299                     }
00300                     __servant.setComponentManager(man, __current);
00301                     return Ice.DispatchStatus.DispatchOK;
00302                 }
00303             };
00304             try
00305             {
00306                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00307                 if(__status == Ice.DispatchStatus.DispatchUserException)
00308                 {
00309                     __direct.throwUserException();
00310                 }
00311                 assert __status == Ice.DispatchStatus.DispatchOK;
00312             }
00313             finally
00314             {
00315                 __direct.destroy();
00316             }
00317         }
00318         catch(Ice.SystemException __ex)
00319         {
00320             throw __ex;
00321         }
00322         catch(java.lang.Throwable __ex)
00323         {
00324             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00325         }
00326     }
00327 
00328     public void
00329     setID(final String id, java.util.Map<String, String> __ctx)
00330         throws IceInternal.LocalExceptionWrapper
00331     {
00332         final Ice.Current __current = new Ice.Current();
00333         __initCurrent(__current, "setID", Ice.OperationMode.Normal, __ctx);
00334         IceInternal.Direct __direct = null;
00335         try
00336         {
00337             __direct = new IceInternal.Direct(__current)
00338             {
00339                 public Ice.DispatchStatus run(Ice.Object __obj)
00340                 {
00341                     WorkingMemoryReaderComponent __servant = null;
00342                     try
00343                     {
00344                         __servant = (WorkingMemoryReaderComponent)__obj;
00345                     }
00346                     catch(ClassCastException __ex)
00347                     {
00348                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00349                     }
00350                     __servant.setID(id, __current);
00351                     return Ice.DispatchStatus.DispatchOK;
00352                 }
00353             };
00354             try
00355             {
00356                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00357                 if(__status == Ice.DispatchStatus.DispatchUserException)
00358                 {
00359                     __direct.throwUserException();
00360                 }
00361                 assert __status == Ice.DispatchStatus.DispatchOK;
00362             }
00363             finally
00364             {
00365                 __direct.destroy();
00366             }
00367         }
00368         catch(Ice.SystemException __ex)
00369         {
00370             throw __ex;
00371         }
00372         catch(java.lang.Throwable __ex)
00373         {
00374             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00375         }
00376     }
00377 
00378     public void
00379     setTimeServer(final TimeServerPrx ts, java.util.Map<String, String> __ctx)
00380         throws IceInternal.LocalExceptionWrapper
00381     {
00382         final Ice.Current __current = new Ice.Current();
00383         __initCurrent(__current, "setTimeServer", Ice.OperationMode.Normal, __ctx);
00384         IceInternal.Direct __direct = null;
00385         try
00386         {
00387             __direct = new IceInternal.Direct(__current)
00388             {
00389                 public Ice.DispatchStatus run(Ice.Object __obj)
00390                 {
00391                     WorkingMemoryReaderComponent __servant = null;
00392                     try
00393                     {
00394                         __servant = (WorkingMemoryReaderComponent)__obj;
00395                     }
00396                     catch(ClassCastException __ex)
00397                     {
00398                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00399                     }
00400                     __servant.setTimeServer(ts, __current);
00401                     return Ice.DispatchStatus.DispatchOK;
00402                 }
00403             };
00404             try
00405             {
00406                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00407                 if(__status == Ice.DispatchStatus.DispatchUserException)
00408                 {
00409                     __direct.throwUserException();
00410                 }
00411                 assert __status == Ice.DispatchStatus.DispatchOK;
00412             }
00413             finally
00414             {
00415                 __direct.destroy();
00416             }
00417         }
00418         catch(Ice.SystemException __ex)
00419         {
00420             throw __ex;
00421         }
00422         catch(java.lang.Throwable __ex)
00423         {
00424             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00425         }
00426     }
00427 
00428     public void
00429     start(java.util.Map<String, String> __ctx)
00430         throws IceInternal.LocalExceptionWrapper
00431     {
00432         final Ice.Current __current = new Ice.Current();
00433         __initCurrent(__current, "start", Ice.OperationMode.Normal, __ctx);
00434         IceInternal.Direct __direct = null;
00435         try
00436         {
00437             __direct = new IceInternal.Direct(__current)
00438             {
00439                 public Ice.DispatchStatus run(Ice.Object __obj)
00440                 {
00441                     WorkingMemoryReaderComponent __servant = null;
00442                     try
00443                     {
00444                         __servant = (WorkingMemoryReaderComponent)__obj;
00445                     }
00446                     catch(ClassCastException __ex)
00447                     {
00448                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00449                     }
00450                     __servant.start(__current);
00451                     return Ice.DispatchStatus.DispatchOK;
00452                 }
00453             };
00454             try
00455             {
00456                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00457                 if(__status == Ice.DispatchStatus.DispatchUserException)
00458                 {
00459                     __direct.throwUserException();
00460                 }
00461                 assert __status == Ice.DispatchStatus.DispatchOK;
00462             }
00463             finally
00464             {
00465                 __direct.destroy();
00466             }
00467         }
00468         catch(Ice.SystemException __ex)
00469         {
00470             throw __ex;
00471         }
00472         catch(java.lang.Throwable __ex)
00473         {
00474             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00475         }
00476     }
00477 
00478     public void
00479     stop(java.util.Map<String, String> __ctx)
00480         throws IceInternal.LocalExceptionWrapper
00481     {
00482         final Ice.Current __current = new Ice.Current();
00483         __initCurrent(__current, "stop", Ice.OperationMode.Normal, __ctx);
00484         IceInternal.Direct __direct = null;
00485         try
00486         {
00487             __direct = new IceInternal.Direct(__current)
00488             {
00489                 public Ice.DispatchStatus run(Ice.Object __obj)
00490                 {
00491                     WorkingMemoryReaderComponent __servant = null;
00492                     try
00493                     {
00494                         __servant = (WorkingMemoryReaderComponent)__obj;
00495                     }
00496                     catch(ClassCastException __ex)
00497                     {
00498                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00499                     }
00500                     __servant.stop(__current);
00501                     return Ice.DispatchStatus.DispatchOK;
00502                 }
00503             };
00504             try
00505             {
00506                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00507                 if(__status == Ice.DispatchStatus.DispatchUserException)
00508                 {
00509                     __direct.throwUserException();
00510                 }
00511                 assert __status == Ice.DispatchStatus.DispatchOK;
00512             }
00513             finally
00514             {
00515                 __direct.destroy();
00516             }
00517         }
00518         catch(Ice.SystemException __ex)
00519         {
00520             throw __ex;
00521         }
00522         catch(java.lang.Throwable __ex)
00523         {
00524             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00525         }
00526     }
00527 
00528     public void
00529     setWorkingMemory(final WorkingMemoryPrx wm, java.util.Map<String, String> __ctx)
00530         throws IceInternal.LocalExceptionWrapper
00531     {
00532         final Ice.Current __current = new Ice.Current();
00533         __initCurrent(__current, "setWorkingMemory", Ice.OperationMode.Normal, __ctx);
00534         IceInternal.Direct __direct = null;
00535         try
00536         {
00537             __direct = new IceInternal.Direct(__current)
00538             {
00539                 public Ice.DispatchStatus run(Ice.Object __obj)
00540                 {
00541                     WorkingMemoryReaderComponent __servant = null;
00542                     try
00543                     {
00544                         __servant = (WorkingMemoryReaderComponent)__obj;
00545                     }
00546                     catch(ClassCastException __ex)
00547                     {
00548                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00549                     }
00550                     __servant.setWorkingMemory(wm, __current);
00551                     return Ice.DispatchStatus.DispatchOK;
00552                 }
00553             };
00554             try
00555             {
00556                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00557                 if(__status == Ice.DispatchStatus.DispatchUserException)
00558                 {
00559                     __direct.throwUserException();
00560                 }
00561                 assert __status == Ice.DispatchStatus.DispatchOK;
00562             }
00563             finally
00564             {
00565                 __direct.destroy();
00566             }
00567         }
00568         catch(Ice.SystemException __ex)
00569         {
00570             throw __ex;
00571         }
00572         catch(java.lang.Throwable __ex)
00573         {
00574             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00575         }
00576     }
00577 
00578     public void
00579     receiveChangeEvent(final cast.cdl.WorkingMemoryChange wmc, java.util.Map<String, String> __ctx)
00580         throws IceInternal.LocalExceptionWrapper
00581     {
00582         final Ice.Current __current = new Ice.Current();
00583         __initCurrent(__current, "receiveChangeEvent", Ice.OperationMode.Normal, __ctx);
00584         IceInternal.Direct __direct = null;
00585         try
00586         {
00587             __direct = new IceInternal.Direct(__current)
00588             {
00589                 public Ice.DispatchStatus run(Ice.Object __obj)
00590                 {
00591                     WorkingMemoryReaderComponent __servant = null;
00592                     try
00593                     {
00594                         __servant = (WorkingMemoryReaderComponent)__obj;
00595                     }
00596                     catch(ClassCastException __ex)
00597                     {
00598                         throw new Ice.OperationNotExistException(__current.id, __current.facet, __current.operation);
00599                     }
00600                     __servant.receiveChangeEvent(wmc, __current);
00601                     return Ice.DispatchStatus.DispatchOK;
00602                 }
00603             };
00604             try
00605             {
00606                 Ice.DispatchStatus __status = __direct.servant().__collocDispatch(__direct);
00607                 if(__status == Ice.DispatchStatus.DispatchUserException)
00608                 {
00609                     __direct.throwUserException();
00610                 }
00611                 assert __status == Ice.DispatchStatus.DispatchOK;
00612             }
00613             finally
00614             {
00615                 __direct.destroy();
00616             }
00617         }
00618         catch(Ice.SystemException __ex)
00619         {
00620             throw __ex;
00621         }
00622         catch(java.lang.Throwable __ex)
00623         {
00624             IceInternal.LocalExceptionWrapper.throwWrapper(__ex);
00625         }
00626     }
00627 }