CAST Java: /Users/nah/Documents/code/cast/src/java/cast/interfaces/

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 _UnmanagedComponentDelM extends Ice._ObjectDelM implements _UnmanagedComponentDel
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     setWorkingMemory(WorkingMemoryPrx wm, java.util.Map<String, String> __ctx)
00435         throws IceInternal.LocalExceptionWrapper
00436     {
00437         IceInternal.Outgoing __og = __handler.getOutgoing("setWorkingMemory", Ice.OperationMode.Normal, __ctx);
00438         try
00439         {
00440             try
00441             {
00442                 IceInternal.BasicStream __os = __og.os();
00443                 WorkingMemoryPrxHelper.__write(__os, wm);
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 }
/Users/nah/Documents/code/cast/src/java/cast/interfaces/_UnmanagedComponentDelM.java
