CAST Java: /Users/nah/Documents/code/cast/src/java/cast/examples/autogen/_WordServerAsComponentDelM.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.examples.autogen;
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 _WordServerAsComponentDelM extends Ice._ObjectDelM implements _WordServerAsComponentDel
00024 {
00025     public String
00026     getNewWord(java.util.Map<String, String> __ctx)
00027         throws IceInternal.LocalExceptionWrapper
00028     {
00029         IceInternal.Outgoing __og = __handler.getOutgoing("getNewWord", Ice.OperationMode.Normal, __ctx);
00030         try
00031         {
00032             boolean __ok = __og.invoke();
00033             try
00034             {
00035                 if(!__ok)
00036                 {
00037                     try
00038                     {
00039                         __og.throwUserException();
00040                     }
00041                     catch(Ice.UserException __ex)
00042                     {
00043                         throw new Ice.UnknownUserException(__ex.ice_name());
00044                     }
00045                 }
00046                 IceInternal.BasicStream __is = __og.is();
00047                 __is.startReadEncaps();
00048                 String __ret;
00049                 __ret = __is.readString();
00050                 __is.endReadEncaps();
00051                 return __ret;
00052             }
00053             catch(Ice.LocalException __ex)
00054             {
00055                 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00056             }
00057         }
00058         finally
00059         {
00060             __handler.reclaimOutgoing(__og);
00061         }
00062     }
00063 
00064     public void
00065     beat(java.util.Map<String, String> __ctx)
00066         throws IceInternal.LocalExceptionWrapper
00067     {
00068         IceInternal.Outgoing __og = __handler.getOutgoing("beat", Ice.OperationMode.Idempotent, __ctx);
00069         try
00070         {
00071             boolean __ok = __og.invoke();
00072             if(!__og.is().isEmpty())
00073             {
00074                 try
00075                 {
00076                     if(!__ok)
00077                     {
00078                         try
00079                         {
00080                             __og.throwUserException();
00081                         }
00082                         catch(Ice.UserException __ex)
00083                         {
00084                             throw new Ice.UnknownUserException(__ex.ice_name());
00085                         }
00086                     }
00087                     __og.is().skipEmptyEncaps();
00088                 }
00089                 catch(Ice.LocalException __ex)
00090                 {
00091                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00092                 }
00093             }
00094         }
00095         finally
00096         {
00097             __handler.reclaimOutgoing(__og);
00098         }
00099     }
00100 
00101     public void
00102     configure(java.util.Map<java.lang.String, java.lang.String> config, java.util.Map<String, String> __ctx)
00103         throws IceInternal.LocalExceptionWrapper
00104     {
00105         IceInternal.Outgoing __og = __handler.getOutgoing("configure", Ice.OperationMode.Normal, __ctx);
00106         try
00107         {
00108             try
00109             {
00110                 IceInternal.BasicStream __os = __og.os();
00111                 cast.cdl.StringMapHelper.write(__os, config);
00112             }
00113             catch(Ice.LocalException __ex)
00114             {
00115                 __og.abort(__ex);
00116             }
00117             boolean __ok = __og.invoke();
00118             if(!__og.is().isEmpty())
00119             {
00120                 try
00121                 {
00122                     if(!__ok)
00123                     {
00124                         try
00125                         {
00126                             __og.throwUserException();
00127                         }
00128                         catch(Ice.UserException __ex)
00129                         {
00130                             throw new Ice.UnknownUserException(__ex.ice_name());
00131                         }
00132                     }
00133                     __og.is().skipEmptyEncaps();
00134                 }
00135                 catch(Ice.LocalException __ex)
00136                 {
00137                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00138                 }
00139             }
00140         }
00141         finally
00142         {
00143             __handler.reclaimOutgoing(__og);
00144         }
00145     }
00146 
00147     public void
00148     destroy(java.util.Map<String, String> __ctx)
00149         throws IceInternal.LocalExceptionWrapper
00150     {
00151         IceInternal.Outgoing __og = __handler.getOutgoing("destroy", Ice.OperationMode.Normal, __ctx);
00152         try
00153         {
00154             boolean __ok = __og.invoke();
00155             if(!__og.is().isEmpty())
00156             {
00157                 try
00158                 {
00159                     if(!__ok)
00160                     {
00161                         try
00162                         {
00163                             __og.throwUserException();
00164                         }
00165                         catch(Ice.UserException __ex)
00166                         {
00167                             throw new Ice.UnknownUserException(__ex.ice_name());
00168                         }
00169                     }
00170                     __og.is().skipEmptyEncaps();
00171                 }
00172                 catch(Ice.LocalException __ex)
00173                 {
00174                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00175                 }
00176             }
00177         }
00178         finally
00179         {
00180             __handler.reclaimOutgoing(__og);
00181         }
00182     }
00183 
00184     public String
00185     getID(java.util.Map<String, String> __ctx)
00186         throws IceInternal.LocalExceptionWrapper
00187     {
00188         IceInternal.Outgoing __og = __handler.getOutgoing("getID", Ice.OperationMode.Idempotent, __ctx);
00189         try
00190         {
00191             boolean __ok = __og.invoke();
00192             try
00193             {
00194                 if(!__ok)
00195                 {
00196                     try
00197                     {
00198                         __og.throwUserException();
00199                     }
00200                     catch(Ice.UserException __ex)
00201                     {
00202                         throw new Ice.UnknownUserException(__ex.ice_name());
00203                     }
00204                 }
00205                 IceInternal.BasicStream __is = __og.is();
00206                 __is.startReadEncaps();
00207                 String __ret;
00208                 __ret = __is.readString();
00209                 __is.endReadEncaps();
00210                 return __ret;
00211             }
00212             catch(Ice.LocalException __ex)
00213             {
00214                 throw new IceInternal.LocalExceptionWrapper(__ex, false);
00215             }
00216         }
00217         finally
00218         {
00219             __handler.reclaimOutgoing(__og);
00220         }
00221     }
00222 
00223     public void
00224     run(java.util.Map<String, String> __ctx)
00225         throws IceInternal.LocalExceptionWrapper
00226     {
00227         IceInternal.Outgoing __og = __handler.getOutgoing("run", Ice.OperationMode.Normal, __ctx);
00228         try
00229         {
00230             boolean __ok = __og.invoke();
00231             if(!__og.is().isEmpty())
00232             {
00233                 try
00234                 {
00235                     if(!__ok)
00236                     {
00237                         try
00238                         {
00239                             __og.throwUserException();
00240                         }
00241                         catch(Ice.UserException __ex)
00242                         {
00243                             throw new Ice.UnknownUserException(__ex.ice_name());
00244                         }
00245                     }
00246                     __og.is().skipEmptyEncaps();
00247                 }
00248                 catch(Ice.LocalException __ex)
00249                 {
00250                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00251                 }
00252             }
00253         }
00254         finally
00255         {
00256             __handler.reclaimOutgoing(__og);
00257         }
00258     }
00259 
00260     public void
00261     setComponentManager(cast.interfaces.ComponentManagerPrx man, java.util.Map<String, String> __ctx)
00262         throws IceInternal.LocalExceptionWrapper
00263     {
00264         IceInternal.Outgoing __og = __handler.getOutgoing("setComponentManager", Ice.OperationMode.Normal, __ctx);
00265         try
00266         {
00267             try
00268             {
00269                 IceInternal.BasicStream __os = __og.os();
00270                 cast.interfaces.ComponentManagerPrxHelper.__write(__os, man);
00271             }
00272             catch(Ice.LocalException __ex)
00273             {
00274                 __og.abort(__ex);
00275             }
00276             boolean __ok = __og.invoke();
00277             if(!__og.is().isEmpty())
00278             {
00279                 try
00280                 {
00281                     if(!__ok)
00282                     {
00283                         try
00284                         {
00285                             __og.throwUserException();
00286                         }
00287                         catch(Ice.UserException __ex)
00288                         {
00289                             throw new Ice.UnknownUserException(__ex.ice_name());
00290                         }
00291                     }
00292                     __og.is().skipEmptyEncaps();
00293                 }
00294                 catch(Ice.LocalException __ex)
00295                 {
00296                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00297                 }
00298             }
00299         }
00300         finally
00301         {
00302             __handler.reclaimOutgoing(__og);
00303         }
00304     }
00305 
00306     public void
00307     setID(String id, java.util.Map<String, String> __ctx)
00308         throws IceInternal.LocalExceptionWrapper
00309     {
00310         IceInternal.Outgoing __og = __handler.getOutgoing("setID", Ice.OperationMode.Normal, __ctx);
00311         try
00312         {
00313             try
00314             {
00315                 IceInternal.BasicStream __os = __og.os();
00316                 __os.writeString(id);
00317             }
00318             catch(Ice.LocalException __ex)
00319             {
00320                 __og.abort(__ex);
00321             }
00322             boolean __ok = __og.invoke();
00323             if(!__og.is().isEmpty())
00324             {
00325                 try
00326                 {
00327                     if(!__ok)
00328                     {
00329                         try
00330                         {
00331                             __og.throwUserException();
00332                         }
00333                         catch(Ice.UserException __ex)
00334                         {
00335                             throw new Ice.UnknownUserException(__ex.ice_name());
00336                         }
00337                     }
00338                     __og.is().skipEmptyEncaps();
00339                 }
00340                 catch(Ice.LocalException __ex)
00341                 {
00342                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00343                 }
00344             }
00345         }
00346         finally
00347         {
00348             __handler.reclaimOutgoing(__og);
00349         }
00350     }
00351 
00352     public void
00353     setTimeServer(cast.interfaces.TimeServerPrx ts, java.util.Map<String, String> __ctx)
00354         throws IceInternal.LocalExceptionWrapper
00355     {
00356         IceInternal.Outgoing __og = __handler.getOutgoing("setTimeServer", Ice.OperationMode.Normal, __ctx);
00357         try
00358         {
00359             try
00360             {
00361                 IceInternal.BasicStream __os = __og.os();
00362                 cast.interfaces.TimeServerPrxHelper.__write(__os, ts);
00363             }
00364             catch(Ice.LocalException __ex)
00365             {
00366                 __og.abort(__ex);
00367             }
00368             boolean __ok = __og.invoke();
00369             if(!__og.is().isEmpty())
00370             {
00371                 try
00372                 {
00373                     if(!__ok)
00374                     {
00375                         try
00376                         {
00377                             __og.throwUserException();
00378                         }
00379                         catch(Ice.UserException __ex)
00380                         {
00381                             throw new Ice.UnknownUserException(__ex.ice_name());
00382                         }
00383                     }
00384                     __og.is().skipEmptyEncaps();
00385                 }
00386                 catch(Ice.LocalException __ex)
00387                 {
00388                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00389                 }
00390             }
00391         }
00392         finally
00393         {
00394             __handler.reclaimOutgoing(__og);
00395         }
00396     }
00397 
00398     public void
00399     start(java.util.Map<String, String> __ctx)
00400         throws IceInternal.LocalExceptionWrapper
00401     {
00402         IceInternal.Outgoing __og = __handler.getOutgoing("start", Ice.OperationMode.Normal, __ctx);
00403         try
00404         {
00405             boolean __ok = __og.invoke();
00406             if(!__og.is().isEmpty())
00407             {
00408                 try
00409                 {
00410                     if(!__ok)
00411                     {
00412                         try
00413                         {
00414                             __og.throwUserException();
00415                         }
00416                         catch(Ice.UserException __ex)
00417                         {
00418                             throw new Ice.UnknownUserException(__ex.ice_name());
00419                         }
00420                     }
00421                     __og.is().skipEmptyEncaps();
00422                 }
00423                 catch(Ice.LocalException __ex)
00424                 {
00425                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00426                 }
00427             }
00428         }
00429         finally
00430         {
00431             __handler.reclaimOutgoing(__og);
00432         }
00433     }
00434 
00435     public void
00436     stop(java.util.Map<String, String> __ctx)
00437         throws IceInternal.LocalExceptionWrapper
00438     {
00439         IceInternal.Outgoing __og = __handler.getOutgoing("stop", Ice.OperationMode.Normal, __ctx);
00440         try
00441         {
00442             boolean __ok = __og.invoke();
00443             if(!__og.is().isEmpty())
00444             {
00445                 try
00446                 {
00447                     if(!__ok)
00448                     {
00449                         try
00450                         {
00451                             __og.throwUserException();
00452                         }
00453                         catch(Ice.UserException __ex)
00454                         {
00455                             throw new Ice.UnknownUserException(__ex.ice_name());
00456                         }
00457                     }
00458                     __og.is().skipEmptyEncaps();
00459                 }
00460                 catch(Ice.LocalException __ex)
00461                 {
00462                     throw new IceInternal.LocalExceptionWrapper(__ex, false);
00463                 }
00464             }
00465         }
00466         finally
00467         {
00468             __handler.reclaimOutgoing(__og);
00469         }
00470     }
00471 }