Main Page | Packages | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | Related Pages

_SctApiIPCStub.java

00001 package Sct_SctApi;
00002 
00003 
00012 // TOP LEVEL:
00013 public class _SctApiIPCStub extends org.omg.CORBA.portable.ObjectImpl implements Sct_SctApi.SctApiIPC
00014 {
00015 
00016   public ipc.servantPackage.info information ()
00017   {
00018             org.omg.CORBA.portable.InputStream $in = null;
00019             try {
00020                 org.omg.CORBA.portable.OutputStream $out = _request ("_get_information", true);
00021                 $in = _invoke ($out);
00022                 ipc.servantPackage.info $result = ipc.servantPackage.infoHelper.read ($in);
00023                 return $result;
00024             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00025                 $in = $ex.getInputStream ();
00026                 String _id = $ex.getId ();
00027                 throw new org.omg.CORBA.MARSHAL (_id);
00028             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00029                 return information (        );
00030             } finally {
00031                 _releaseReply ($in);
00032             }
00033   } // information
00034 
00035   public void shutdown ()
00036   {
00037             org.omg.CORBA.portable.InputStream $in = null;
00038             try {
00039                 org.omg.CORBA.portable.OutputStream $out = _request ("shutdown", true);
00040                 $in = _invoke ($out);
00041                 return;
00042             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00043                 $in = $ex.getInputStream ();
00044                 String _id = $ex.getId ();
00045                 throw new org.omg.CORBA.MARSHAL (_id);
00046             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00047                 shutdown (        );
00048             } finally {
00049                 _releaseReply ($in);
00050             }
00051   } // shutdown
00052 
00053   public void awaitResponse (int partition, int crate, int rod)
00054   {
00055             org.omg.CORBA.portable.InputStream $in = null;
00056             try {
00057                 org.omg.CORBA.portable.OutputStream $out = _request ("awaitResponse", true);
00058                 $out.write_ulong (partition);
00059                 $out.write_ulong (crate);
00060                 $out.write_ulong (rod);
00061                 $in = _invoke ($out);
00062                 return;
00063             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00064                 $in = $ex.getInputStream ();
00065                 String _id = $ex.getId ();
00066                 throw new org.omg.CORBA.MARSHAL (_id);
00067             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00068                 awaitResponse (partition, crate, rod        );
00069             } finally {
00070                 _releaseReply ($in);
00071             }
00072   } // awaitResponse
00073 
00074   public int[] getResponse (int partition, int crate, int rod)
00075   {
00076             org.omg.CORBA.portable.InputStream $in = null;
00077             try {
00078                 org.omg.CORBA.portable.OutputStream $out = _request ("getResponse", true);
00079                 $out.write_ulong (partition);
00080                 $out.write_ulong (crate);
00081                 $out.write_ulong (rod);
00082                 $in = _invoke ($out);
00083                 int $result[] = Sct_SctApi.DataBlockHelper.read ($in);
00084                 return $result;
00085             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00086                 $in = $ex.getInputStream ();
00087                 String _id = $ex.getId ();
00088                 throw new org.omg.CORBA.MARSHAL (_id);
00089             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00090                 return getResponse (partition, crate, rod        );
00091             } finally {
00092                 _releaseReply ($in);
00093             }
00094   } // getResponse
00095 
00096   public void createDebugPrimList () throws Sct_SctApi.SctApiException
00097   {
00098             org.omg.CORBA.portable.InputStream $in = null;
00099             try {
00100                 org.omg.CORBA.portable.OutputStream $out = _request ("createDebugPrimList", true);
00101                 $in = _invoke ($out);
00102                 return;
00103             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00104                 $in = $ex.getInputStream ();
00105                 String _id = $ex.getId ();
00106                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00107                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00108                 else
00109                     throw new org.omg.CORBA.MARSHAL (_id);
00110             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00111                 createDebugPrimList (        );
00112             } finally {
00113                 _releaseReply ($in);
00114             }
00115   } // createDebugPrimList
00116 
00117   public void addDebugPrimList (int index, int id, int version, int[] body) throws Sct_SctApi.SctApiException
00118   {
00119             org.omg.CORBA.portable.InputStream $in = null;
00120             try {
00121                 org.omg.CORBA.portable.OutputStream $out = _request ("addDebugPrimList", true);
00122                 $out.write_long (index);
00123                 $out.write_long (id);
00124                 $out.write_long (version);
00125                 Sct_SctApi.DataBlockHelper.write ($out, body);
00126                 $in = _invoke ($out);
00127                 return;
00128             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00129                 $in = $ex.getInputStream ();
00130                 String _id = $ex.getId ();
00131                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00132                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00133                 else
00134                     throw new org.omg.CORBA.MARSHAL (_id);
00135             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00136                 addDebugPrimList (index, id, version, body        );
00137             } finally {
00138                 _releaseReply ($in);
00139             }
00140   } // addDebugPrimList
00141 
00142   public void sendDebugPrimList (int partition, int crate, int rod) throws Sct_SctApi.SctApiException
00143   {
00144             org.omg.CORBA.portable.InputStream $in = null;
00145             try {
00146                 org.omg.CORBA.portable.OutputStream $out = _request ("sendDebugPrimList", true);
00147                 $out.write_ulong (partition);
00148                 $out.write_ulong (crate);
00149                 $out.write_ulong (rod);
00150                 $in = _invoke ($out);
00151                 return;
00152             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00153                 $in = $ex.getInputStream ();
00154                 String _id = $ex.getId ();
00155                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00156                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00157                 else
00158                     throw new org.omg.CORBA.MARSHAL (_id);
00159             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00160                 sendDebugPrimList (partition, crate, rod        );
00161             } finally {
00162                 _releaseReply ($in);
00163             }
00164   } // sendDebugPrimList
00165 
00166   public void sendDebugSlavePrimList (int partition, int crate, int rod, int slave, boolean await, boolean response) throws Sct_SctApi.SctApiException
00167   {
00168             org.omg.CORBA.portable.InputStream $in = null;
00169             try {
00170                 org.omg.CORBA.portable.OutputStream $out = _request ("sendDebugSlavePrimList", true);
00171                 $out.write_ulong (partition);
00172                 $out.write_ulong (crate);
00173                 $out.write_ulong (rod);
00174                 $out.write_ulong (slave);
00175                 $out.write_boolean (await);
00176                 $out.write_boolean (response);
00177                 $in = _invoke ($out);
00178                 return;
00179             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00180                 $in = $ex.getInputStream ();
00181                 String _id = $ex.getId ();
00182                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00183                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00184                 else
00185                     throw new org.omg.CORBA.MARSHAL (_id);
00186             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00187                 sendDebugSlavePrimList (partition, crate, rod, slave, await, response        );
00188             } finally {
00189                 _releaseReply ($in);
00190             }
00191   } // sendDebugSlavePrimList
00192 
00193   public void flashLED (int partition, int crate, int rod, short slaveNumber, int period, int flashes) throws Sct_SctApi.SctApiException
00194   {
00195             org.omg.CORBA.portable.InputStream $in = null;
00196             try {
00197                 org.omg.CORBA.portable.OutputStream $out = _request ("flashLED", true);
00198                 $out.write_ulong (partition);
00199                 $out.write_ulong (crate);
00200                 $out.write_ulong (rod);
00201                 $out.write_ushort (slaveNumber);
00202                 $out.write_ulong (period);
00203                 $out.write_ulong (flashes);
00204                 $in = _invoke ($out);
00205                 return;
00206             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00207                 $in = $ex.getInputStream ();
00208                 String _id = $ex.getId ();
00209                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00210                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00211                 else
00212                     throw new org.omg.CORBA.MARSHAL (_id);
00213             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00214                 flashLED (partition, crate, rod, slaveNumber, period, flashes        );
00215             } finally {
00216                 _releaseReply ($in);
00217             }
00218   } // flashLED
00219 
00220   public void echo (int partition, int crate, int rod, int[] data) throws Sct_SctApi.SctApiException
00221   {
00222             org.omg.CORBA.portable.InputStream $in = null;
00223             try {
00224                 org.omg.CORBA.portable.OutputStream $out = _request ("echo", true);
00225                 $out.write_ulong (partition);
00226                 $out.write_ulong (crate);
00227                 $out.write_ulong (rod);
00228                 Sct_SctApi.DataBlockHelper.write ($out, data);
00229                 $in = _invoke ($out);
00230                 return;
00231             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00232                 $in = $ex.getInputStream ();
00233                 String _id = $ex.getId ();
00234                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00235                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00236                 else
00237                     throw new org.omg.CORBA.MARSHAL (_id);
00238             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00239                 echo (partition, crate, rod, data        );
00240             } finally {
00241                 _releaseReply ($in);
00242             }
00243   } // echo
00244 
00245   public void printABCDModule (int mid)
00246   {
00247             org.omg.CORBA.portable.InputStream $in = null;
00248             try {
00249                 org.omg.CORBA.portable.OutputStream $out = _request ("printABCDModule", true);
00250                 $out.write_ulong (mid);
00251                 $in = _invoke ($out);
00252                 return;
00253             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00254                 $in = $ex.getInputStream ();
00255                 String _id = $ex.getId ();
00256                 throw new org.omg.CORBA.MARSHAL (_id);
00257             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00258                 printABCDModule (mid        );
00259             } finally {
00260                 _releaseReply ($in);
00261             }
00262   } // printABCDModule
00263 
00264   public void printABCDRodModule (int mid, Sct_SctApi.BankType bank)
00265   {
00266             org.omg.CORBA.portable.InputStream $in = null;
00267             try {
00268                 org.omg.CORBA.portable.OutputStream $out = _request ("printABCDRodModule", true);
00269                 $out.write_ulong (mid);
00270                 Sct_SctApi.BankTypeHelper.write ($out, bank);
00271                 $in = _invoke ($out);
00272                 return;
00273             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00274                 $in = $ex.getInputStream ();
00275                 String _id = $ex.getId ();
00276                 throw new org.omg.CORBA.MARSHAL (_id);
00277             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00278                 printABCDRodModule (mid, bank        );
00279             } finally {
00280                 _releaseReply ($in);
00281             }
00282   } // printABCDRodModule
00283 
00284   public void decodeEvent (int partition, int crate, int rod, short sl, short index, boolean extFlag, boolean errorType)
00285   {
00286             org.omg.CORBA.portable.InputStream $in = null;
00287             try {
00288                 org.omg.CORBA.portable.OutputStream $out = _request ("decodeEvent", true);
00289                 $out.write_ulong (partition);
00290                 $out.write_ulong (crate);
00291                 $out.write_ulong (rod);
00292                 $out.write_short (sl);
00293                 $out.write_short (index);
00294                 $out.write_boolean (extFlag);
00295                 $out.write_boolean (errorType);
00296                 $in = _invoke ($out);
00297                 return;
00298             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00299                 $in = $ex.getInputStream ();
00300                 String _id = $ex.getId ();
00301                 throw new org.omg.CORBA.MARSHAL (_id);
00302             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00303                 decodeEvent (partition, crate, rod, sl, index, extFlag, errorType        );
00304             } finally {
00305                 _releaseReply ($in);
00306             }
00307   } // decodeEvent
00308 
00309   public void configureBOC (int partition, int crate, int rod)
00310   {
00311             org.omg.CORBA.portable.InputStream $in = null;
00312             try {
00313                 org.omg.CORBA.portable.OutputStream $out = _request ("configureBOC", true);
00314                 $out.write_ulong (partition);
00315                 $out.write_ulong (crate);
00316                 $out.write_ulong (rod);
00317                 $in = _invoke ($out);
00318                 return;
00319             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00320                 $in = $ex.getInputStream ();
00321                 String _id = $ex.getId ();
00322                 throw new org.omg.CORBA.MARSHAL (_id);
00323             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00324                 configureBOC (partition, crate, rod        );
00325             } finally {
00326                 _releaseReply ($in);
00327             }
00328   } // configureBOC
00329 
00330   public double[] getBOCMonitorArray (int partition, int crate, int rod)
00331   {
00332             org.omg.CORBA.portable.InputStream $in = null;
00333             try {
00334                 org.omg.CORBA.portable.OutputStream $out = _request ("getBOCMonitorArray", true);
00335                 $out.write_ulong (partition);
00336                 $out.write_ulong (crate);
00337                 $out.write_ulong (rod);
00338                 $in = _invoke ($out);
00339                 double $result[] = Sct_SctApi.BOCMonitorSequenceHelper.read ($in);
00340                 return $result;
00341             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00342                 $in = $ex.getInputStream ();
00343                 String _id = $ex.getId ();
00344                 throw new org.omg.CORBA.MARSHAL (_id);
00345             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00346                 return getBOCMonitorArray (partition, crate, rod        );
00347             } finally {
00348                 _releaseReply ($in);
00349             }
00350   } // getBOCMonitorArray
00351 
00352   public int getRodSlot (int partition, int crate, int rod)
00353   {
00354             org.omg.CORBA.portable.InputStream $in = null;
00355             try {
00356                 org.omg.CORBA.portable.OutputStream $out = _request ("getRodSlot", true);
00357                 $out.write_ulong (partition);
00358                 $out.write_ulong (crate);
00359                 $out.write_ulong (rod);
00360                 $in = _invoke ($out);
00361                 int $result = $in.read_ulong ();
00362                 return $result;
00363             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00364                 $in = $ex.getInputStream ();
00365                 String _id = $ex.getId ();
00366                 throw new org.omg.CORBA.MARSHAL (_id);
00367             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00368                 return getRodSlot (partition, crate, rod        );
00369             } finally {
00370                 _releaseReply ($in);
00371             }
00372   } // getRodSlot
00373 
00374   public void testLinkOutSelect (int partition, int crate, int rod, int link)
00375   {
00376             org.omg.CORBA.portable.InputStream $in = null;
00377             try {
00378                 org.omg.CORBA.portable.OutputStream $out = _request ("testLinkOutSelect", true);
00379                 $out.write_ulong (partition);
00380                 $out.write_ulong (crate);
00381                 $out.write_ulong (rod);
00382                 $out.write_ulong (link);
00383                 $in = _invoke ($out);
00384                 return;
00385             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00386                 $in = $ex.getInputStream ();
00387                 String _id = $ex.getId ();
00388                 throw new org.omg.CORBA.MARSHAL (_id);
00389             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00390                 testLinkOutSelect (partition, crate, rod, link        );
00391             } finally {
00392                 _releaseReply ($in);
00393             }
00394   } // testLinkOutSelect
00395 
00396   public int testLinkOutRetrieve (int partition, int crate, int rod)
00397   {
00398             org.omg.CORBA.portable.InputStream $in = null;
00399             try {
00400                 org.omg.CORBA.portable.OutputStream $out = _request ("testLinkOutRetrieve", true);
00401                 $out.write_ulong (partition);
00402                 $out.write_ulong (crate);
00403                 $out.write_ulong (rod);
00404                 $in = _invoke ($out);
00405                 int $result = $in.read_ulong ();
00406                 return $result;
00407             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00408                 $in = $ex.getInputStream ();
00409                 String _id = $ex.getId ();
00410                 throw new org.omg.CORBA.MARSHAL (_id);
00411             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00412                 return testLinkOutRetrieve (partition, crate, rod        );
00413             } finally {
00414                 _releaseReply ($in);
00415             }
00416   } // testLinkOutRetrieve
00417 
00418   public boolean isRODPresent (int partition, int crate, int rod)
00419   {
00420             org.omg.CORBA.portable.InputStream $in = null;
00421             try {
00422                 org.omg.CORBA.portable.OutputStream $out = _request ("isRODPresent", true);
00423                 $out.write_ulong (partition);
00424                 $out.write_ulong (crate);
00425                 $out.write_ulong (rod);
00426                 $in = _invoke ($out);
00427                 boolean $result = $in.read_boolean ();
00428                 return $result;
00429             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00430                 $in = $ex.getInputStream ();
00431                 String _id = $ex.getId ();
00432                 throw new org.omg.CORBA.MARSHAL (_id);
00433             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00434                 return isRODPresent (partition, crate, rod        );
00435             } finally {
00436                 _releaseReply ($in);
00437             }
00438   } // isRODPresent
00439 
00440   public Sct_SctApi.CrateIPC getCrate (Sct.Corba.UniqueCrateIdentifier ucid)
00441   {
00442             org.omg.CORBA.portable.InputStream $in = null;
00443             try {
00444                 org.omg.CORBA.portable.OutputStream $out = _request ("getCrate", true);
00445                 Sct.Corba.UCIDHelper.write ($out, ucid);
00446                 $in = _invoke ($out);
00447                 Sct_SctApi.CrateIPC $result = Sct_SctApi.CrateIPCHelper.read ($in);
00448                 return $result;
00449             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00450                 $in = $ex.getInputStream ();
00451                 String _id = $ex.getId ();
00452                 throw new org.omg.CORBA.MARSHAL (_id);
00453             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00454                 return getCrate (ucid        );
00455             } finally {
00456                 _releaseReply ($in);
00457             }
00458   } // getCrate
00459 
00460   public Sct_SctApi.CrateIPC getCrateLegacy (int partition, int crate)
00461   {
00462             org.omg.CORBA.portable.InputStream $in = null;
00463             try {
00464                 org.omg.CORBA.portable.OutputStream $out = _request ("getCrateLegacy", true);
00465                 $out.write_ulong (partition);
00466                 $out.write_ulong (crate);
00467                 $in = _invoke ($out);
00468                 Sct_SctApi.CrateIPC $result = Sct_SctApi.CrateIPCHelper.read ($in);
00469                 return $result;
00470             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00471                 $in = $ex.getInputStream ();
00472                 String _id = $ex.getId ();
00473                 throw new org.omg.CORBA.MARSHAL (_id);
00474             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00475                 return getCrateLegacy (partition, crate        );
00476             } finally {
00477                 _releaseReply ($in);
00478             }
00479   } // getCrateLegacy
00480 
00481   public Sct.Corba.UniqueCrateIdentifier[] getCrateUCIDs ()
00482   {
00483             org.omg.CORBA.portable.InputStream $in = null;
00484             try {
00485                 org.omg.CORBA.portable.OutputStream $out = _request ("getCrateUCIDs", true);
00486                 $in = _invoke ($out);
00487                 Sct.Corba.UniqueCrateIdentifier $result[] = Sct.Corba.UCIDsHelper.read ($in);
00488                 return $result;
00489             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00490                 $in = $ex.getInputStream ();
00491                 String _id = $ex.getId ();
00492                 throw new org.omg.CORBA.MARSHAL (_id);
00493             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00494                 return getCrateUCIDs (        );
00495             } finally {
00496                 _releaseReply ($in);
00497             }
00498   } // getCrateUCIDs
00499 
00500   public void standardRegisterDumpURID (Sct.Corba.UniqueRodIdentifier urid)
00501   {
00502             org.omg.CORBA.portable.InputStream $in = null;
00503             try {
00504                 org.omg.CORBA.portable.OutputStream $out = _request ("standardRegisterDumpURID", true);
00505                 Sct.Corba.URIDHelper.write ($out, urid);
00506                 $in = _invoke ($out);
00507                 return;
00508             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00509                 $in = $ex.getInputStream ();
00510                 String _id = $ex.getId ();
00511                 throw new org.omg.CORBA.MARSHAL (_id);
00512             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00513                 standardRegisterDumpURID (urid        );
00514             } finally {
00515                 _releaseReply ($in);
00516             }
00517   } // standardRegisterDumpURID
00518 
00519   public Sct_SctApi.Scan createScan ()
00520   {
00521             org.omg.CORBA.portable.InputStream $in = null;
00522             try {
00523                 org.omg.CORBA.portable.OutputStream $out = _request ("createScan", true);
00524                 $in = _invoke ($out);
00525                 Sct_SctApi.Scan $result = Sct_SctApi.ScanHelper.read ($in);
00526                 return $result;
00527             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00528                 $in = $ex.getInputStream ();
00529                 String _id = $ex.getId ();
00530                 throw new org.omg.CORBA.MARSHAL (_id);
00531             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00532                 return createScan (        );
00533             } finally {
00534                 _releaseReply ($in);
00535             }
00536   } // createScan
00537 
00538   public Sct_SctApi.Scan getDefaultScan ()
00539   {
00540             org.omg.CORBA.portable.InputStream $in = null;
00541             try {
00542                 org.omg.CORBA.portable.OutputStream $out = _request ("getDefaultScan", true);
00543                 $in = _invoke ($out);
00544                 Sct_SctApi.Scan $result = Sct_SctApi.ScanHelper.read ($in);
00545                 return $result;
00546             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00547                 $in = $ex.getInputStream ();
00548                 String _id = $ex.getId ();
00549                 throw new org.omg.CORBA.MARSHAL (_id);
00550             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00551                 return getDefaultScan (        );
00552             } finally {
00553                 _releaseReply ($in);
00554             }
00555   } // getDefaultScan
00556 
00557 
00558   // Nobody seems to use these two:
00559   public Sct_SctApi.Trigger createTrigger ()
00560   {
00561             org.omg.CORBA.portable.InputStream $in = null;
00562             try {
00563                 org.omg.CORBA.portable.OutputStream $out = _request ("createTrigger", true);
00564                 $in = _invoke ($out);
00565                 Sct_SctApi.Trigger $result = Sct_SctApi.TriggerHelper.read ($in);
00566                 return $result;
00567             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00568                 $in = $ex.getInputStream ();
00569                 String _id = $ex.getId ();
00570                 throw new org.omg.CORBA.MARSHAL (_id);
00571             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00572                 return createTrigger (        );
00573             } finally {
00574                 _releaseReply ($in);
00575             }
00576   } // createTrigger
00577 
00578 
00579   // Trigger getDefaultTrigger();
00580   public Sct_SctApi.Scan[] knownScans ()
00581   {
00582             org.omg.CORBA.portable.InputStream $in = null;
00583             try {
00584                 org.omg.CORBA.portable.OutputStream $out = _request ("knownScans", true);
00585                 $in = _invoke ($out);
00586                 Sct_SctApi.Scan $result[] = Sct_SctApi.ScanListHelper.read ($in);
00587                 return $result;
00588             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00589                 $in = $ex.getInputStream ();
00590                 String _id = $ex.getId ();
00591                 throw new org.omg.CORBA.MARSHAL (_id);
00592             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00593                 return knownScans (        );
00594             } finally {
00595                 _releaseReply ($in);
00596             }
00597   } // knownScans
00598 
00599 
00600   // Translation
00601   public int findModuleSerial (String sn)
00602   {
00603             org.omg.CORBA.portable.InputStream $in = null;
00604             try {
00605                 org.omg.CORBA.portable.OutputStream $out = _request ("findModuleSerial", true);
00606                 $out.write_string (sn);
00607                 $in = _invoke ($out);
00608                 int $result = $in.read_ulong ();
00609                 return $result;
00610             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00611                 $in = $ex.getInputStream ();
00612                 String _id = $ex.getId ();
00613                 throw new org.omg.CORBA.MARSHAL (_id);
00614             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00615                 return findModuleSerial (sn        );
00616             } finally {
00617                 _releaseReply ($in);
00618             }
00619   } // findModuleSerial
00620 
00621   public String convertToString (int mid)
00622   {
00623             org.omg.CORBA.portable.InputStream $in = null;
00624             try {
00625                 org.omg.CORBA.portable.OutputStream $out = _request ("convertToString", true);
00626                 $out.write_ulong (mid);
00627                 $in = _invoke ($out);
00628                 String $result = $in.read_string ();
00629                 return $result;
00630             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00631                 $in = $ex.getInputStream ();
00632                 String _id = $ex.getId ();
00633                 throw new org.omg.CORBA.MARSHAL (_id);
00634             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00635                 return convertToString (mid        );
00636             } finally {
00637                 _releaseReply ($in);
00638             }
00639   } // convertToString
00640 
00641   public int findModule (short mur, short number)
00642   {
00643             org.omg.CORBA.portable.InputStream $in = null;
00644             try {
00645                 org.omg.CORBA.portable.OutputStream $out = _request ("findModule", true);
00646                 $out.write_ushort (mur);
00647                 $out.write_ushort (number);
00648                 $in = _invoke ($out);
00649                 int $result = $in.read_ulong ();
00650                 return $result;
00651             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00652                 $in = $ex.getInputStream ();
00653                 String _id = $ex.getId ();
00654                 throw new org.omg.CORBA.MARSHAL (_id);
00655             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00656                 return findModule (mur, number        );
00657             } finally {
00658                 _releaseReply ($in);
00659             }
00660   } // findModule
00661 
00662   public int findModuleRod (int partition, int crate, int rod, int channel)
00663   {
00664             org.omg.CORBA.portable.InputStream $in = null;
00665             try {
00666                 org.omg.CORBA.portable.OutputStream $out = _request ("findModuleRod", true);
00667                 $out.write_ulong (partition);
00668                 $out.write_ulong (crate);
00669                 $out.write_ulong (rod);
00670                 $out.write_ulong (channel);
00671                 $in = _invoke ($out);
00672                 int $result = $in.read_ulong ();
00673                 return $result;
00674             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00675                 $in = $ex.getInputStream ();
00676                 String _id = $ex.getId ();
00677                 throw new org.omg.CORBA.MARSHAL (_id);
00678             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00679                 return findModuleRod (partition, crate, rod, channel        );
00680             } finally {
00681                 _releaseReply ($in);
00682             }
00683   } // findModuleRod
00684 
00685 
00686   //  pair<INT32, INT32> convertToMUR(in unsigned long mid);
00687   public int findBarrelModule (int barrel, int row, short number)
00688   {
00689             org.omg.CORBA.portable.InputStream $in = null;
00690             try {
00691                 org.omg.CORBA.portable.OutputStream $out = _request ("findBarrelModule", true);
00692                 $out.write_ulong (barrel);
00693                 $out.write_ulong (row);
00694                 $out.write_short (number);
00695                 $in = _invoke ($out);
00696                 int $result = $in.read_ulong ();
00697                 return $result;
00698             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00699                 $in = $ex.getInputStream ();
00700                 String _id = $ex.getId ();
00701                 throw new org.omg.CORBA.MARSHAL (_id);
00702             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00703                 return findBarrelModule (barrel, row, number        );
00704             } finally {
00705                 _releaseReply ($in);
00706             }
00707   } // findBarrelModule
00708 
00709   public void convertToBarrelModule (int mid, org.omg.CORBA.IntHolder barrel, org.omg.CORBA.IntHolder row, org.omg.CORBA.ShortHolder number)
00710   {
00711             org.omg.CORBA.portable.InputStream $in = null;
00712             try {
00713                 org.omg.CORBA.portable.OutputStream $out = _request ("convertToBarrelModule", true);
00714                 $out.write_ulong (mid);
00715                 $in = _invoke ($out);
00716                 barrel.value = $in.read_ulong ();
00717                 row.value = $in.read_ulong ();
00718                 number.value = $in.read_short ();
00719                 return;
00720             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00721                 $in = $ex.getInputStream ();
00722                 String _id = $ex.getId ();
00723                 throw new org.omg.CORBA.MARSHAL (_id);
00724             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00725                 convertToBarrelModule (mid, barrel, row, number        );
00726             } finally {
00727                 _releaseReply ($in);
00728             }
00729   } // convertToBarrelModule
00730 
00731   public int findEndcapModule (int disk, int ring, int number)
00732   {
00733             org.omg.CORBA.portable.InputStream $in = null;
00734             try {
00735                 org.omg.CORBA.portable.OutputStream $out = _request ("findEndcapModule", true);
00736                 $out.write_long (disk);
00737                 $out.write_long (ring);
00738                 $out.write_long (number);
00739                 $in = _invoke ($out);
00740                 int $result = $in.read_ulong ();
00741                 return $result;
00742             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00743                 $in = $ex.getInputStream ();
00744                 String _id = $ex.getId ();
00745                 throw new org.omg.CORBA.MARSHAL (_id);
00746             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00747                 return findEndcapModule (disk, ring, number        );
00748             } finally {
00749                 _releaseReply ($in);
00750             }
00751   } // findEndcapModule
00752 
00753   public void convertToEndcapModule (int mid, org.omg.CORBA.IntHolder disk, org.omg.CORBA.IntHolder ring, org.omg.CORBA.IntHolder number)
00754   {
00755             org.omg.CORBA.portable.InputStream $in = null;
00756             try {
00757                 org.omg.CORBA.portable.OutputStream $out = _request ("convertToEndcapModule", true);
00758                 $out.write_ulong (mid);
00759                 $in = _invoke ($out);
00760                 disk.value = $in.read_long ();
00761                 ring.value = $in.read_ulong ();
00762                 number.value = $in.read_ulong ();
00763                 return;
00764             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00765                 $in = $ex.getInputStream ();
00766                 String _id = $ex.getId ();
00767                 throw new org.omg.CORBA.MARSHAL (_id);
00768             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00769                 convertToEndcapModule (mid, disk, ring, number        );
00770             } finally {
00771                 _releaseReply ($in);
00772             }
00773   } // convertToEndcapModule
00774 
00775 
00776   // Scans
00777   public void doScan (Sct_SctApi.Scan thisScan) throws Sct_SctApi.SctApiException
00778   {
00779             org.omg.CORBA.portable.InputStream $in = null;
00780             try {
00781                 org.omg.CORBA.portable.OutputStream $out = _request ("doScan", true);
00782                 Sct_SctApi.ScanHelper.write ($out, thisScan);
00783                 $in = _invoke ($out);
00784                 return;
00785             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00786                 $in = $ex.getInputStream ();
00787                 String _id = $ex.getId ();
00788                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00789                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00790                 else
00791                     throw new org.omg.CORBA.MARSHAL (_id);
00792             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00793                 doScan (thisScan        );
00794             } finally {
00795                 _releaseReply ($in);
00796             }
00797   } // doScan
00798 
00799   public void doRawScan (Sct_SctApi.Scan thisScan, int delay, int width, boolean configure, boolean clockByTwo) throws Sct_SctApi.SctApiException
00800   {
00801             org.omg.CORBA.portable.InputStream $in = null;
00802             try {
00803                 org.omg.CORBA.portable.OutputStream $out = _request ("doRawScan", true);
00804                 Sct_SctApi.ScanHelper.write ($out, thisScan);
00805                 $out.write_long (delay);
00806                 $out.write_long (width);
00807                 $out.write_boolean (configure);
00808                 $out.write_boolean (clockByTwo);
00809                 $in = _invoke ($out);
00810                 return;
00811             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00812                 $in = $ex.getInputStream ();
00813                 String _id = $ex.getId ();
00814                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00815                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00816                 else
00817                     throw new org.omg.CORBA.MARSHAL (_id);
00818             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00819                 doRawScan (thisScan, delay, width, configure, clockByTwo        );
00820             } finally {
00821                 _releaseReply ($in);
00822             }
00823   } // doRawScan
00824 
00825   public void abortScan ()
00826   {
00827             org.omg.CORBA.portable.InputStream $in = null;
00828             try {
00829                 org.omg.CORBA.portable.OutputStream $out = _request ("abortScan", true);
00830                 $in = _invoke ($out);
00831                 return;
00832             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00833                 $in = $ex.getInputStream ();
00834                 String _id = $ex.getId ();
00835                 throw new org.omg.CORBA.MARSHAL (_id);
00836             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00837                 abortScan (        );
00838             } finally {
00839                 _releaseReply ($in);
00840             }
00841   } // abortScan
00842 
00843 
00844   // postcondition: hasFinishedScanning()==true;
00845   public boolean hasFinishedScanning ()
00846   {
00847             org.omg.CORBA.portable.InputStream $in = null;
00848             try {
00849                 org.omg.CORBA.portable.OutputStream $out = _request ("hasFinishedScanning", true);
00850                 $in = _invoke ($out);
00851                 boolean $result = $in.read_boolean ();
00852                 return $result;
00853             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00854                 $in = $ex.getInputStream ();
00855                 String _id = $ex.getId ();
00856                 throw new org.omg.CORBA.MARSHAL (_id);
00857             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00858                 return hasFinishedScanning (        );
00859             } finally {
00860                 _releaseReply ($in);
00861             }
00862   } // hasFinishedScanning
00863 
00864   public void modifyABCDMask (int mid, int[] mask)
00865   {
00866             org.omg.CORBA.portable.InputStream $in = null;
00867             try {
00868                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDMask", true);
00869                 $out.write_ulong (mid);
00870                 Sct_SctApi.DataBlockHelper.write ($out, mask);
00871                 $in = _invoke ($out);
00872                 return;
00873             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00874                 $in = $ex.getInputStream ();
00875                 String _id = $ex.getId ();
00876                 throw new org.omg.CORBA.MARSHAL (_id);
00877             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00878                 modifyABCDMask (mid, mask        );
00879             } finally {
00880                 _releaseReply ($in);
00881             }
00882   } // modifyABCDMask
00883 
00884   public void modifyABCDTrims (int mid, short[] trims)
00885   {
00886             org.omg.CORBA.portable.InputStream $in = null;
00887             try {
00888                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDTrims", true);
00889                 $out.write_ulong (mid);
00890                 Sct_SctApi.CharBlockHelper.write ($out, trims);
00891                 $in = _invoke ($out);
00892                 return;
00893             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00894                 $in = $ex.getInputStream ();
00895                 String _id = $ex.getId ();
00896                 throw new org.omg.CORBA.MARSHAL (_id);
00897             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00898                 modifyABCDTrims (mid, trims        );
00899             } finally {
00900                 _releaseReply ($in);
00901             }
00902   } // modifyABCDTrims
00903 
00904   public void modifyABCDRC (int mid, int chip, short index, double p0, double p1, double p2)
00905   {
00906             org.omg.CORBA.portable.InputStream $in = null;
00907             try {
00908                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDRC", true);
00909                 $out.write_ulong (mid);
00910                 $out.write_ulong (chip);
00911                 $out.write_ushort (index);
00912                 $out.write_double (p0);
00913                 $out.write_double (p1);
00914                 $out.write_double (p2);
00915                 $in = _invoke ($out);
00916                 return;
00917             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00918                 $in = $ex.getInputStream ();
00919                 String _id = $ex.getId ();
00920                 throw new org.omg.CORBA.MARSHAL (_id);
00921             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00922                 modifyABCDRC (mid, chip, index, p0, p1, p2        );
00923             } finally {
00924                 _releaseReply ($in);
00925             }
00926   } // modifyABCDRC
00927 
00928 
00929   // must be different prototypes
00930   public void modifyABCDVar (int typ, double var)
00931   {
00932             org.omg.CORBA.portable.InputStream $in = null;
00933             try {
00934                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDVar", true);
00935                 $out.write_ulong (typ);
00936                 $out.write_double (var);
00937                 $in = _invoke ($out);
00938                 return;
00939             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00940                 $in = $ex.getInputStream ();
00941                 String _id = $ex.getId ();
00942                 throw new org.omg.CORBA.MARSHAL (_id);
00943             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00944                 modifyABCDVar (typ, var        );
00945             } finally {
00946                 _releaseReply ($in);
00947             }
00948   } // modifyABCDVar
00949 
00950   public void modifyABCDModuleVar (int mid, int typ, double var)
00951   {
00952             org.omg.CORBA.portable.InputStream $in = null;
00953             try {
00954                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDModuleVar", true);
00955                 $out.write_ulong (mid);
00956                 $out.write_ulong (typ);
00957                 $out.write_double (var);
00958                 $in = _invoke ($out);
00959                 return;
00960             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00961                 $in = $ex.getInputStream ();
00962                 String _id = $ex.getId ();
00963                 throw new org.omg.CORBA.MARSHAL (_id);
00964             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00965                 modifyABCDModuleVar (mid, typ, var        );
00966             } finally {
00967                 _releaseReply ($in);
00968             }
00969   } // modifyABCDModuleVar
00970 
00971   public void modifyABCDChipVar (int mid, int chip, int typ, double var)
00972   {
00973             org.omg.CORBA.portable.InputStream $in = null;
00974             try {
00975                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDChipVar", true);
00976                 $out.write_ulong (mid);
00977                 $out.write_ulong (chip);
00978                 $out.write_ulong (typ);
00979                 $out.write_double (var);
00980                 $in = _invoke ($out);
00981                 return;
00982             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00983                 $in = $ex.getInputStream ();
00984                 String _id = $ex.getId ();
00985                 throw new org.omg.CORBA.MARSHAL (_id);
00986             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00987                 modifyABCDChipVar (mid, chip, typ, var        );
00988             } finally {
00989                 _releaseReply ($in);
00990             }
00991   } // modifyABCDChipVar
00992 
00993   public void modifyABCDVarROD (int typ, double var, Sct_SctApi.BankType[] banks)
00994   {
00995             org.omg.CORBA.portable.InputStream $in = null;
00996             try {
00997                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDVarROD", true);
00998                 $out.write_ulong (typ);
00999                 $out.write_double (var);
01000                 Sct_SctApi.BankListHelper.write ($out, banks);
01001                 $in = _invoke ($out);
01002                 return;
01003             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01004                 $in = $ex.getInputStream ();
01005                 String _id = $ex.getId ();
01006                 throw new org.omg.CORBA.MARSHAL (_id);
01007             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01008                 modifyABCDVarROD (typ, var, banks        );
01009             } finally {
01010                 _releaseReply ($in);
01011             }
01012   } // modifyABCDVarROD
01013 
01014   public void modifyABCDModuleVarROD (int mid, int typ, double var, Sct_SctApi.BankType[] banks)
01015   {
01016             org.omg.CORBA.portable.InputStream $in = null;
01017             try {
01018                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDModuleVarROD", true);
01019                 $out.write_ulong (mid);
01020                 $out.write_ulong (typ);
01021                 $out.write_double (var);
01022                 Sct_SctApi.BankListHelper.write ($out, banks);
01023                 $in = _invoke ($out);
01024                 return;
01025             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01026                 $in = $ex.getInputStream ();
01027                 String _id = $ex.getId ();
01028                 throw new org.omg.CORBA.MARSHAL (_id);
01029             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01030                 modifyABCDModuleVarROD (mid, typ, var, banks        );
01031             } finally {
01032                 _releaseReply ($in);
01033             }
01034   } // modifyABCDModuleVarROD
01035 
01036   public void modifyBOCParam (int partition, int crate, int rod, int channel, int type, int val)
01037   {
01038             org.omg.CORBA.portable.InputStream $in = null;
01039             try {
01040                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyBOCParam", true);
01041                 $out.write_ulong (partition);
01042                 $out.write_ulong (crate);
01043                 $out.write_ulong (rod);
01044                 $out.write_ulong (channel);
01045                 $out.write_ulong (type);
01046                 $out.write_ulong (val);
01047                 $in = _invoke ($out);
01048                 return;
01049             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01050                 $in = $ex.getInputStream ();
01051                 String _id = $ex.getId ();
01052                 throw new org.omg.CORBA.MARSHAL (_id);
01053             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01054                 modifyBOCParam (partition, crate, rod, channel, type, val        );
01055             } finally {
01056                 _releaseReply ($in);
01057             }
01058   } // modifyBOCParam
01059 
01060 
01062   public void getABCDModules (Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
01063   {
01064             org.omg.CORBA.portable.InputStream $in = null;
01065             try {
01066                 org.omg.CORBA.portable.OutputStream $out = _request ("getABCDModules", true);
01067                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01068                 $in = _invoke ($out);
01069                 return;
01070             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01071                 $in = $ex.getInputStream ();
01072                 String _id = $ex.getId ();
01073                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01074                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01075                 else
01076                     throw new org.omg.CORBA.MARSHAL (_id);
01077             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01078                 getABCDModules (bank        );
01079             } finally {
01080                 _releaseReply ($in);
01081             }
01082   } // getABCDModules
01083 
01084   public void getABCDModule (int mid, Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
01085   {
01086             org.omg.CORBA.portable.InputStream $in = null;
01087             try {
01088                 org.omg.CORBA.portable.OutputStream $out = _request ("getABCDModule", true);
01089                 $out.write_ulong (mid);
01090                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01091                 $in = _invoke ($out);
01092                 return;
01093             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01094                 $in = $ex.getInputStream ();
01095                 String _id = $ex.getId ();
01096                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01097                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01098                 else
01099                     throw new org.omg.CORBA.MARSHAL (_id);
01100             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01101                 getABCDModule (mid, bank        );
01102             } finally {
01103                 _releaseReply ($in);
01104             }
01105   } // getABCDModule
01106 
01107   public void setABCDModule (int mid, Sct_SctApi.BankType[] banks) throws Sct_SctApi.SctApiException
01108   {
01109             org.omg.CORBA.portable.InputStream $in = null;
01110             try {
01111                 org.omg.CORBA.portable.OutputStream $out = _request ("setABCDModule", true);
01112                 $out.write_ulong (mid);
01113                 Sct_SctApi.BankListHelper.write ($out, banks);
01114                 $in = _invoke ($out);
01115                 return;
01116             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01117                 $in = $ex.getInputStream ();
01118                 String _id = $ex.getId ();
01119                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01120                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01121                 else
01122                     throw new org.omg.CORBA.MARSHAL (_id);
01123             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01124                 setABCDModule (mid, banks        );
01125             } finally {
01126                 _releaseReply ($in);
01127             }
01128   } // setABCDModule
01129 
01130   public void setABCDModules (Sct_SctApi.BankType[] bank) throws Sct_SctApi.SctApiException
01131   {
01132             org.omg.CORBA.portable.InputStream $in = null;
01133             try {
01134                 org.omg.CORBA.portable.OutputStream $out = _request ("setABCDModules", true);
01135                 Sct_SctApi.BankListHelper.write ($out, bank);
01136                 $in = _invoke ($out);
01137                 return;
01138             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01139                 $in = $ex.getInputStream ();
01140                 String _id = $ex.getId ();
01141                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01142                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01143                 else
01144                     throw new org.omg.CORBA.MARSHAL (_id);
01145             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01146                 setABCDModules (bank        );
01147             } finally {
01148                 _releaseReply ($in);
01149             }
01150   } // setABCDModules
01151 
01152   public void copyABCDModule (int mid, Sct_SctApi.BankType from, Sct_SctApi.BankType[] to) throws Sct_SctApi.SctApiException
01153   {
01154             org.omg.CORBA.portable.InputStream $in = null;
01155             try {
01156                 org.omg.CORBA.portable.OutputStream $out = _request ("copyABCDModule", true);
01157                 $out.write_ulong (mid);
01158                 Sct_SctApi.BankTypeHelper.write ($out, from);
01159                 Sct_SctApi.BankListHelper.write ($out, to);
01160                 $in = _invoke ($out);
01161                 return;
01162             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01163                 $in = $ex.getInputStream ();
01164                 String _id = $ex.getId ();
01165                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01166                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01167                 else
01168                     throw new org.omg.CORBA.MARSHAL (_id);
01169             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01170                 copyABCDModule (mid, from, to        );
01171             } finally {
01172                 _releaseReply ($in);
01173             }
01174   } // copyABCDModule
01175 
01176   public void copyABCDModules (Sct_SctApi.BankType from, Sct_SctApi.BankType[] to) throws Sct_SctApi.SctApiException
01177   {
01178             org.omg.CORBA.portable.InputStream $in = null;
01179             try {
01180                 org.omg.CORBA.portable.OutputStream $out = _request ("copyABCDModules", true);
01181                 Sct_SctApi.BankTypeHelper.write ($out, from);
01182                 Sct_SctApi.BankListHelper.write ($out, to);
01183                 $in = _invoke ($out);
01184                 return;
01185             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01186                 $in = $ex.getInputStream ();
01187                 String _id = $ex.getId ();
01188                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01189                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01190                 else
01191                     throw new org.omg.CORBA.MARSHAL (_id);
01192             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01193                 copyABCDModules (from, to        );
01194             } finally {
01195                 _releaseReply ($in);
01196             }
01197   } // copyABCDModules
01198 
01199   public void sendABCDModule (int mid, Sct_SctApi.BankType bank, int type) throws Sct_SctApi.SctApiException
01200   {
01201             org.omg.CORBA.portable.InputStream $in = null;
01202             try {
01203                 org.omg.CORBA.portable.OutputStream $out = _request ("sendABCDModule", true);
01204                 $out.write_ulong (mid);
01205                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01206                 $out.write_ulong (type);
01207                 $in = _invoke ($out);
01208                 return;
01209             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01210                 $in = $ex.getInputStream ();
01211                 String _id = $ex.getId ();
01212                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01213                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01214                 else
01215                     throw new org.omg.CORBA.MARSHAL (_id);
01216             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01217                 sendABCDModule (mid, bank, type        );
01218             } finally {
01219                 _releaseReply ($in);
01220             }
01221   } // sendABCDModule
01222 
01223   public void sendABCDModules (Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
01224   {
01225             org.omg.CORBA.portable.InputStream $in = null;
01226             try {
01227                 org.omg.CORBA.portable.OutputStream $out = _request ("sendABCDModules", true);
01228                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01229                 $in = _invoke ($out);
01230                 return;
01231             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01232                 $in = $ex.getInputStream ();
01233                 String _id = $ex.getId ();
01234                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01235                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01236                 else
01237                     throw new org.omg.CORBA.MARSHAL (_id);
01238             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01239                 sendABCDModules (bank        );
01240             } finally {
01241                 _releaseReply ($in);
01242             }
01243   } // sendABCDModules
01244 
01245   public void storeModuleConfigurations () throws Sct_SctApi.SctApiException
01246   {
01247             org.omg.CORBA.portable.InputStream $in = null;
01248             try {
01249                 org.omg.CORBA.portable.OutputStream $out = _request ("storeModuleConfigurations", true);
01250                 $in = _invoke ($out);
01251                 return;
01252             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01253                 $in = $ex.getInputStream ();
01254                 String _id = $ex.getId ();
01255                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01256                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01257                 else
01258                     throw new org.omg.CORBA.MARSHAL (_id);
01259             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01260                 storeModuleConfigurations (        );
01261             } finally {
01262                 _releaseReply ($in);
01263             }
01264   } // storeModuleConfigurations
01265 
01266   public void storeBOCConfigurations () throws Sct_SctApi.SctApiException
01267   {
01268             org.omg.CORBA.portable.InputStream $in = null;
01269             try {
01270                 org.omg.CORBA.portable.OutputStream $out = _request ("storeBOCConfigurations", true);
01271                 $in = _invoke ($out);
01272                 return;
01273             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01274                 $in = $ex.getInputStream ();
01275                 String _id = $ex.getId ();
01276                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01277                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01278                 else
01279                     throw new org.omg.CORBA.MARSHAL (_id);
01280             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01281                 storeBOCConfigurations (        );
01282             } finally {
01283                 _releaseReply ($in);
01284             }
01285   } // storeBOCConfigurations
01286 
01287   public void configureAllModules () throws Sct_SctApi.SctApiException
01288   {
01289             org.omg.CORBA.portable.InputStream $in = null;
01290             try {
01291                 org.omg.CORBA.portable.OutputStream $out = _request ("configureAllModules", true);
01292                 $in = _invoke ($out);
01293                 return;
01294             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01295                 $in = $ex.getInputStream ();
01296                 String _id = $ex.getId ();
01297                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01298                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01299                 else
01300                     throw new org.omg.CORBA.MARSHAL (_id);
01301             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01302                 configureAllModules (        );
01303             } finally {
01304                 _releaseReply ($in);
01305             }
01306   } // configureAllModules
01307 
01308 
01310   public sctConf.ABCDModule retrieveModule (int mid)
01311   {
01312             org.omg.CORBA.portable.InputStream $in = null;
01313             try {
01314                 org.omg.CORBA.portable.OutputStream $out = _request ("retrieveModule", true);
01315                 $out.write_ulong (mid);
01316                 $in = _invoke ($out);
01317                 sctConf.ABCDModule $result = sctConf.ABCDModuleHelper.read ($in);
01318                 return $result;
01319             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01320                 $in = $ex.getInputStream ();
01321                 String _id = $ex.getId ();
01322                 throw new org.omg.CORBA.MARSHAL (_id);
01323             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01324                 return retrieveModule (mid        );
01325             } finally {
01326                 _releaseReply ($in);
01327             }
01328   } // retrieveModule
01329 
01330   public sctConf.BOCChannelConfig[] currentBOCSetup (int partition, int crate, int rod)
01331   {
01332             org.omg.CORBA.portable.InputStream $in = null;
01333             try {
01334                 org.omg.CORBA.portable.OutputStream $out = _request ("currentBOCSetup", true);
01335                 $out.write_ulong (partition);
01336                 $out.write_ulong (crate);
01337                 $out.write_ulong (rod);
01338                 $in = _invoke ($out);
01339                 sctConf.BOCChannelConfig $result[] = Sct_SctApi.BOCChannelListHelper.read ($in);
01340                 return $result;
01341             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01342                 $in = $ex.getInputStream ();
01343                 String _id = $ex.getId ();
01344                 throw new org.omg.CORBA.MARSHAL (_id);
01345             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01346                 return currentBOCSetup (partition, crate, rod        );
01347             } finally {
01348                 _releaseReply ($in);
01349             }
01350   } // currentBOCSetup
01351 
01352   public sctConf.BOCGlobalConfig currentBOCRegisters (int partition, int crate, int rod)
01353   {
01354             org.omg.CORBA.portable.InputStream $in = null;
01355             try {
01356                 org.omg.CORBA.portable.OutputStream $out = _request ("currentBOCRegisters", true);
01357                 $out.write_ulong (partition);
01358                 $out.write_ulong (crate);
01359                 $out.write_ulong (rod);
01360                 $in = _invoke ($out);
01361                 sctConf.BOCGlobalConfig $result = sctConf.BOCGlobalConfigHelper.read ($in);
01362                 return $result;
01363             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01364                 $in = $ex.getInputStream ();
01365                 String _id = $ex.getId ();
01366                 throw new org.omg.CORBA.MARSHAL (_id);
01367             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01368                 return currentBOCRegisters (partition, crate, rod        );
01369             } finally {
01370                 _releaseReply ($in);
01371             }
01372   } // currentBOCRegisters
01373 
01374   public void sendL1A (int partition, int crate, int rod)
01375   {
01376             org.omg.CORBA.portable.InputStream $in = null;
01377             try {
01378                 org.omg.CORBA.portable.OutputStream $out = _request ("sendL1A", true);
01379                 $out.write_ulong (partition);
01380                 $out.write_ulong (crate);
01381                 $out.write_ulong (rod);
01382                 $in = _invoke ($out);
01383                 return;
01384             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01385                 $in = $ex.getInputStream ();
01386                 String _id = $ex.getId ();
01387                 throw new org.omg.CORBA.MARSHAL (_id);
01388             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01389                 sendL1A (partition, crate, rod        );
01390             } finally {
01391                 _releaseReply ($in);
01392             }
01393   } // sendL1A
01394 
01395   public void sendTrigger (int partition, int crate, int rod, Sct_SctApi.Trigger trig)
01396   {
01397             org.omg.CORBA.portable.InputStream $in = null;
01398             try {
01399                 org.omg.CORBA.portable.OutputStream $out = _request ("sendTrigger", true);
01400                 $out.write_ulong (partition);
01401                 $out.write_ulong (crate);
01402                 $out.write_ulong (rod);
01403                 Sct_SctApi.TriggerHelper.write ($out, trig);
01404                 $in = _invoke ($out);
01405                 return;
01406             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01407                 $in = $ex.getInputStream ();
01408                 String _id = $ex.getId ();
01409                 throw new org.omg.CORBA.MARSHAL (_id);
01410             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01411                 sendTrigger (partition, crate, rod, trig        );
01412             } finally {
01413                 _releaseReply ($in);
01414             }
01415   } // sendTrigger
01416 
01417 
01418   /* *************  TIM functs **************/
01419   public void timSetFrequency (int partition, int crate, double trigFreq, double rstFreq)
01420   {
01421             org.omg.CORBA.portable.InputStream $in = null;
01422             try {
01423                 org.omg.CORBA.portable.OutputStream $out = _request ("timSetFrequency", true);
01424                 $out.write_ulong (partition);
01425                 $out.write_ulong (crate);
01426                 $out.write_double (trigFreq);
01427                 $out.write_double (rstFreq);
01428                 $in = _invoke ($out);
01429                 return;
01430             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01431                 $in = $ex.getInputStream ();
01432                 String _id = $ex.getId ();
01433                 throw new org.omg.CORBA.MARSHAL (_id);
01434             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01435                 timSetFrequency (partition, crate, trigFreq, rstFreq        );
01436             } finally {
01437                 _releaseReply ($in);
01438             }
01439   } // timSetFrequency
01440 
01441   public void freeTriggers (int partition, int crate)
01442   {
01443             org.omg.CORBA.portable.InputStream $in = null;
01444             try {
01445                 org.omg.CORBA.portable.OutputStream $out = _request ("freeTriggers", true);
01446                 $out.write_ulong (partition);
01447                 $out.write_ulong (crate);
01448                 $in = _invoke ($out);
01449                 return;
01450             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01451                 $in = $ex.getInputStream ();
01452                 String _id = $ex.getId ();
01453                 throw new org.omg.CORBA.MARSHAL (_id);
01454             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01455                 freeTriggers (partition, crate        );
01456             } finally {
01457                 _releaseReply ($in);
01458             }
01459   } // freeTriggers
01460 
01461   public void stopTriggers (int partition, int crate)
01462   {
01463             org.omg.CORBA.portable.InputStream $in = null;
01464             try {
01465                 org.omg.CORBA.portable.OutputStream $out = _request ("stopTriggers", true);
01466                 $out.write_ulong (partition);
01467                 $out.write_ulong (crate);
01468                 $in = _invoke ($out);
01469                 return;
01470             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01471                 $in = $ex.getInputStream ();
01472                 String _id = $ex.getId ();
01473                 throw new org.omg.CORBA.MARSHAL (_id);
01474             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01475                 stopTriggers (partition, crate        );
01476             } finally {
01477                 _releaseReply ($in);
01478             }
01479   } // stopTriggers
01480 
01481   public void timL1A (int partition, int crate)
01482   {
01483             org.omg.CORBA.portable.InputStream $in = null;
01484             try {
01485                 org.omg.CORBA.portable.OutputStream $out = _request ("timL1A", true);
01486                 $out.write_ulong (partition);
01487                 $out.write_ulong (crate);
01488                 $in = _invoke ($out);
01489                 return;
01490             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01491                 $in = $ex.getInputStream ();
01492                 String _id = $ex.getId ();
01493                 throw new org.omg.CORBA.MARSHAL (_id);
01494             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01495                 timL1A (partition, crate        );
01496             } finally {
01497                 _releaseReply ($in);
01498             }
01499   } // timL1A
01500 
01501   public void timCalL1A (int partition, int crate, short delay)
01502   {
01503             org.omg.CORBA.portable.InputStream $in = null;
01504             try {
01505                 org.omg.CORBA.portable.OutputStream $out = _request ("timCalL1A", true);
01506                 $out.write_ulong (partition);
01507                 $out.write_ulong (crate);
01508                 $out.write_short (delay);
01509                 $in = _invoke ($out);
01510                 return;
01511             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01512                 $in = $ex.getInputStream ();
01513                 String _id = $ex.getId ();
01514                 throw new org.omg.CORBA.MARSHAL (_id);
01515             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01516                 timCalL1A (partition, crate, delay        );
01517             } finally {
01518                 _releaseReply ($in);
01519             }
01520   } // timCalL1A
01521 
01522   public short timReadRegister (int partition, int crate, short value)
01523   {
01524             org.omg.CORBA.portable.InputStream $in = null;
01525             try {
01526                 org.omg.CORBA.portable.OutputStream $out = _request ("timReadRegister", true);
01527                 $out.write_ulong (partition);
01528                 $out.write_ulong (crate);
01529                 $out.write_short (value);
01530                 $in = _invoke ($out);
01531                 short $result = $in.read_short ();
01532                 return $result;
01533             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01534                 $in = $ex.getInputStream ();
01535                 String _id = $ex.getId ();
01536                 throw new org.omg.CORBA.MARSHAL (_id);
01537             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01538                 return timReadRegister (partition, crate, value        );
01539             } finally {
01540                 _releaseReply ($in);
01541             }
01542   } // timReadRegister
01543 
01544   public void timWriteRegister (int partition, int crate, short reg, short value)
01545   {
01546             org.omg.CORBA.portable.InputStream $in = null;
01547             try {
01548                 org.omg.CORBA.portable.OutputStream $out = _request ("timWriteRegister", true);
01549                 $out.write_ulong (partition);
01550                 $out.write_ulong (crate);
01551                 $out.write_short (reg);
01552                 $out.write_short (value);
01553                 $in = _invoke ($out);
01554                 return;
01555             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01556                 $in = $ex.getInputStream ();
01557                 String _id = $ex.getId ();
01558                 throw new org.omg.CORBA.MARSHAL (_id);
01559             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01560                 timWriteRegister (partition, crate, reg, value        );
01561             } finally {
01562                 _releaseReply ($in);
01563             }
01564   } // timWriteRegister
01565 
01566   public void sendTimTrigger (int partition, int crate, Sct_SctApi.Trigger trig)
01567   {
01568             org.omg.CORBA.portable.InputStream $in = null;
01569             try {
01570                 org.omg.CORBA.portable.OutputStream $out = _request ("sendTimTrigger", true);
01571                 $out.write_ulong (partition);
01572                 $out.write_ulong (crate);
01573                 Sct_SctApi.TriggerHelper.write ($out, trig);
01574                 $in = _invoke ($out);
01575                 return;
01576             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01577                 $in = $ex.getInputStream ();
01578                 String _id = $ex.getId ();
01579                 throw new org.omg.CORBA.MARSHAL (_id);
01580             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01581                 sendTimTrigger (partition, crate, trig        );
01582             } finally {
01583                 _releaseReply ($in);
01584             }
01585   } // sendTimTrigger
01586 
01587   public Sct_SctApi.AutoConfigResult[] autoConfigureScan () throws Sct_SctApi.SctApiException
01588   {
01589             org.omg.CORBA.portable.InputStream $in = null;
01590             try {
01591                 org.omg.CORBA.portable.OutputStream $out = _request ("autoConfigureScan", true);
01592                 $in = _invoke ($out);
01593                 Sct_SctApi.AutoConfigResult $result[] = Sct_SctApi.AutoResultListHelper.read ($in);
01594                 return $result;
01595             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01596                 $in = $ex.getInputStream ();
01597                 String _id = $ex.getId ();
01598                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01599                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01600                 else
01601                     throw new org.omg.CORBA.MARSHAL (_id);
01602             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01603                 return autoConfigureScan (        );
01604             } finally {
01605                 _releaseReply ($in);
01606             }
01607   } // autoConfigureScan
01608 
01609   public boolean checkAllModulesProbe (String chars) throws Sct_SctApi.SctApiException
01610   {
01611             org.omg.CORBA.portable.InputStream $in = null;
01612             try {
01613                 org.omg.CORBA.portable.OutputStream $out = _request ("checkAllModulesProbe", true);
01614                 $out.write_string (chars);
01615                 $in = _invoke ($out);
01616                 boolean $result = $in.read_boolean ();
01617                 return $result;
01618             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01619                 $in = $ex.getInputStream ();
01620                 String _id = $ex.getId ();
01621                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01622                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01623                 else
01624                     throw new org.omg.CORBA.MARSHAL (_id);
01625             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01626                 return checkAllModulesProbe (chars        );
01627             } finally {
01628                 _releaseReply ($in);
01629             }
01630   } // checkAllModulesProbe
01631 
01632   public short[] probe (int partition, int crate, int rod)
01633   {
01634             org.omg.CORBA.portable.InputStream $in = null;
01635             try {
01636                 org.omg.CORBA.portable.OutputStream $out = _request ("probe", true);
01637                 $out.write_ulong (partition);
01638                 $out.write_ulong (crate);
01639                 $out.write_ulong (rod);
01640                 $in = _invoke ($out);
01641                 short $result[] = Sct_SctApi.CharBlockHelper.read ($in);
01642                 return $result;
01643             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01644                 $in = $ex.getInputStream ();
01645                 String _id = $ex.getId ();
01646                 throw new org.omg.CORBA.MARSHAL (_id);
01647             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01648                 return probe (partition, crate, rod        );
01649             } finally {
01650                 _releaseReply ($in);
01651             }
01652   } // probe
01653 
01654   public short[] probeHarness (int partition, int crate, int rod, int harness)
01655   {
01656             org.omg.CORBA.portable.InputStream $in = null;
01657             try {
01658                 org.omg.CORBA.portable.OutputStream $out = _request ("probeHarness", true);
01659                 $out.write_ulong (partition);
01660                 $out.write_ulong (crate);
01661                 $out.write_ulong (rod);
01662                 $out.write_ulong (harness);
01663                 $in = _invoke ($out);
01664                 short $result[] = Sct_SctApi.CharBlockHelper.read ($in);
01665                 return $result;
01666             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01667                 $in = $ex.getInputStream ();
01668                 String _id = $ex.getId ();
01669                 throw new org.omg.CORBA.MARSHAL (_id);
01670             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01671                 return probeHarness (partition, crate, rod, harness        );
01672             } finally {
01673                 _releaseReply ($in);
01674             }
01675   } // probeHarness
01676 
01677   public short[] probeWithTrigger (int partition, int crate, int rod, Sct_SctApi.Trigger trig)
01678   {
01679             org.omg.CORBA.portable.InputStream $in = null;
01680             try {
01681                 org.omg.CORBA.portable.OutputStream $out = _request ("probeWithTrigger", true);
01682                 $out.write_ulong (partition);
01683                 $out.write_ulong (crate);
01684                 $out.write_ulong (rod);
01685                 Sct_SctApi.TriggerHelper.write ($out, trig);
01686                 $in = _invoke ($out);
01687                 short $result[] = Sct_SctApi.CharBlockHelper.read ($in);
01688                 return $result;
01689             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01690                 $in = $ex.getInputStream ();
01691                 String _id = $ex.getId ();
01692                 throw new org.omg.CORBA.MARSHAL (_id);
01693             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01694                 return probeWithTrigger (partition, crate, rod, trig        );
01695             } finally {
01696                 _releaseReply ($in);
01697             }
01698   } // probeWithTrigger
01699 
01700   public short[] probeHarnessWithTrigger (int partition, int crate, int rod, Sct_SctApi.Trigger trig, int harness)
01701   {
01702             org.omg.CORBA.portable.InputStream $in = null;
01703             try {
01704                 org.omg.CORBA.portable.OutputStream $out = _request ("probeHarnessWithTrigger", true);
01705                 $out.write_ulong (partition);
01706                 $out.write_ulong (crate);
01707                 $out.write_ulong (rod);
01708                 Sct_SctApi.TriggerHelper.write ($out, trig);
01709                 $out.write_ulong (harness);
01710                 $in = _invoke ($out);
01711                 short $result[] = Sct_SctApi.CharBlockHelper.read ($in);
01712                 return $result;
01713             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01714                 $in = $ex.getInputStream ();
01715                 String _id = $ex.getId ();
01716                 throw new org.omg.CORBA.MARSHAL (_id);
01717             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01718                 return probeHarnessWithTrigger (partition, crate, rod, trig, harness        );
01719             } finally {
01720                 _releaseReply ($in);
01721             }
01722   } // probeHarnessWithTrigger
01723 
01724   public short[][] probeScanHarnessWithTrigger (int partition, int crate, int rod, Sct_SctApi.Scan trig, int harness)
01725   {
01726             org.omg.CORBA.portable.InputStream $in = null;
01727             try {
01728                 org.omg.CORBA.portable.OutputStream $out = _request ("probeScanHarnessWithTrigger", true);
01729                 $out.write_ulong (partition);
01730                 $out.write_ulong (crate);
01731                 $out.write_ulong (rod);
01732                 Sct_SctApi.ScanHelper.write ($out, trig);
01733                 $out.write_ulong (harness);
01734                 $in = _invoke ($out);
01735                 short $result[][] = Sct_SctApi.CharMatrixHelper.read ($in);
01736                 return $result;
01737             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01738                 $in = $ex.getInputStream ();
01739                 String _id = $ex.getId ();
01740                 throw new org.omg.CORBA.MARSHAL (_id);
01741             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01742                 return probeScanHarnessWithTrigger (partition, crate, rod, trig, harness        );
01743             } finally {
01744                 _releaseReply ($in);
01745             }
01746   } // probeScanHarnessWithTrigger
01747 
01748   public void initialiseAll (int runNumber) throws Sct_SctApi.SctApiException
01749   {
01750             org.omg.CORBA.portable.InputStream $in = null;
01751             try {
01752                 org.omg.CORBA.portable.OutputStream $out = _request ("initialiseAll", true);
01753                 $out.write_ulong (runNumber);
01754                 $in = _invoke ($out);
01755                 return;
01756             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01757                 $in = $ex.getInputStream ();
01758                 String _id = $ex.getId ();
01759                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01760                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01761                 else
01762                     throw new org.omg.CORBA.MARSHAL (_id);
01763             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01764                 initialiseAll (runNumber        );
01765             } finally {
01766                 _releaseReply ($in);
01767             }
01768   } // initialiseAll
01769 
01770   public void shutdownAll () throws Sct_SctApi.SctApiException
01771   {
01772             org.omg.CORBA.portable.InputStream $in = null;
01773             try {
01774                 org.omg.CORBA.portable.OutputStream $out = _request ("shutdownAll", true);
01775                 $in = _invoke ($out);
01776                 return;
01777             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01778                 $in = $ex.getInputStream ();
01779                 String _id = $ex.getId ();
01780                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01781                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01782                 else
01783                     throw new org.omg.CORBA.MARSHAL (_id);
01784             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01785                 shutdownAll (        );
01786             } finally {
01787                 _releaseReply ($in);
01788             }
01789   } // shutdownAll
01790 
01791   public void status ()
01792   {
01793             org.omg.CORBA.portable.InputStream $in = null;
01794             try {
01795                 org.omg.CORBA.portable.OutputStream $out = _request ("status", true);
01796                 $in = _invoke ($out);
01797                 return;
01798             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01799                 $in = $ex.getInputStream ();
01800                 String _id = $ex.getId ();
01801                 throw new org.omg.CORBA.MARSHAL (_id);
01802             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01803                 status (        );
01804             } finally {
01805                 _releaseReply ($in);
01806             }
01807   } // status
01808 
01809   public void setRunNumber (int newRun)
01810   {
01811             org.omg.CORBA.portable.InputStream $in = null;
01812             try {
01813                 org.omg.CORBA.portable.OutputStream $out = _request ("setRunNumber", true);
01814                 $out.write_ulong (newRun);
01815                 $in = _invoke ($out);
01816                 return;
01817             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01818                 $in = $ex.getInputStream ();
01819                 String _id = $ex.getId ();
01820                 throw new org.omg.CORBA.MARSHAL (_id);
01821             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01822                 setRunNumber (newRun        );
01823             } finally {
01824                 _releaseReply ($in);
01825             }
01826   } // setRunNumber
01827 
01828   public void setScanNumber (int newScan)
01829   {
01830             org.omg.CORBA.portable.InputStream $in = null;
01831             try {
01832                 org.omg.CORBA.portable.OutputStream $out = _request ("setScanNumber", true);
01833                 $out.write_ulong (newScan);
01834                 $in = _invoke ($out);
01835                 return;
01836             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01837                 $in = $ex.getInputStream ();
01838                 String _id = $ex.getId ();
01839                 throw new org.omg.CORBA.MARSHAL (_id);
01840             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01841                 setScanNumber (newScan        );
01842             } finally {
01843                 _releaseReply ($in);
01844             }
01845   } // setScanNumber
01846 
01847   public int getRunNumber ()
01848   {
01849             org.omg.CORBA.portable.InputStream $in = null;
01850             try {
01851                 org.omg.CORBA.portable.OutputStream $out = _request ("getRunNumber", true);
01852                 $in = _invoke ($out);
01853                 int $result = $in.read_ulong ();
01854                 return $result;
01855             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01856                 $in = $ex.getInputStream ();
01857                 String _id = $ex.getId ();
01858                 throw new org.omg.CORBA.MARSHAL (_id);
01859             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01860                 return getRunNumber (        );
01861             } finally {
01862                 _releaseReply ($in);
01863             }
01864   } // getRunNumber
01865 
01866   public int getScanNumber ()
01867   {
01868             org.omg.CORBA.portable.InputStream $in = null;
01869             try {
01870                 org.omg.CORBA.portable.OutputStream $out = _request ("getScanNumber", true);
01871                 $in = _invoke ($out);
01872                 int $result = $in.read_ulong ();
01873                 return $result;
01874             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01875                 $in = $ex.getInputStream ();
01876                 String _id = $ex.getId ();
01877                 throw new org.omg.CORBA.MARSHAL (_id);
01878             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01879                 return getScanNumber (        );
01880             } finally {
01881                 _releaseReply ($in);
01882             }
01883   } // getScanNumber
01884 
01885   public void standardRegisterDumpAll ()
01886   {
01887             org.omg.CORBA.portable.InputStream $in = null;
01888             try {
01889                 org.omg.CORBA.portable.OutputStream $out = _request ("standardRegisterDumpAll", true);
01890                 $in = _invoke ($out);
01891                 return;
01892             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01893                 $in = $ex.getInputStream ();
01894                 String _id = $ex.getId ();
01895                 throw new org.omg.CORBA.MARSHAL (_id);
01896             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01897                 standardRegisterDumpAll (        );
01898             } finally {
01899                 _releaseReply ($in);
01900             }
01901   } // standardRegisterDumpAll
01902 
01903   public void lasersOff ()
01904   {
01905             org.omg.CORBA.portable.InputStream $in = null;
01906             try {
01907                 org.omg.CORBA.portable.OutputStream $out = _request ("lasersOff", true);
01908                 $in = _invoke ($out);
01909                 return;
01910             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01911                 $in = $ex.getInputStream ();
01912                 String _id = $ex.getId ();
01913                 throw new org.omg.CORBA.MARSHAL (_id);
01914             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01915                 lasersOff (        );
01916             } finally {
01917                 _releaseReply ($in);
01918             }
01919   } // lasersOff
01920 
01921   public String[] getModuleList ()
01922   {
01923             org.omg.CORBA.portable.InputStream $in = null;
01924             try {
01925                 org.omg.CORBA.portable.OutputStream $out = _request ("getModuleList", true);
01926                 $in = _invoke ($out);
01927                 String $result[] = sctConf.ModuleListHelper.read ($in);
01928                 return $result;
01929             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01930                 $in = $ex.getInputStream ();
01931                 String _id = $ex.getId ();
01932                 throw new org.omg.CORBA.MARSHAL (_id);
01933             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01934                 return getModuleList (        );
01935             } finally {
01936                 _releaseReply ($in);
01937             }
01938   } // getModuleList
01939 
01940   public void unsetDebugOption (String opt)
01941   {
01942             org.omg.CORBA.portable.InputStream $in = null;
01943             try {
01944                 org.omg.CORBA.portable.OutputStream $out = _request ("unsetDebugOption", true);
01945                 $out.write_string (opt);
01946                 $in = _invoke ($out);
01947                 return;
01948             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01949                 $in = $ex.getInputStream ();
01950                 String _id = $ex.getId ();
01951                 throw new org.omg.CORBA.MARSHAL (_id);
01952             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01953                 unsetDebugOption (opt        );
01954             } finally {
01955                 _releaseReply ($in);
01956             }
01957   } // unsetDebugOption
01958 
01959   public void setDebugOption (String opt)
01960   {
01961             org.omg.CORBA.portable.InputStream $in = null;
01962             try {
01963                 org.omg.CORBA.portable.OutputStream $out = _request ("setDebugOption", true);
01964                 $out.write_string (opt);
01965                 $in = _invoke ($out);
01966                 return;
01967             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01968                 $in = $ex.getInputStream ();
01969                 String _id = $ex.getId ();
01970                 throw new org.omg.CORBA.MARSHAL (_id);
01971             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01972                 setDebugOption (opt        );
01973             } finally {
01974                 _releaseReply ($in);
01975             }
01976   } // setDebugOption
01977 
01978   public String[] listDebugOptions ()
01979   {
01980             org.omg.CORBA.portable.InputStream $in = null;
01981             try {
01982                 org.omg.CORBA.portable.OutputStream $out = _request ("listDebugOptions", true);
01983                 $in = _invoke ($out);
01984                 String $result[] = Sct_SctApi.DebugOptionListHelper.read ($in);
01985                 return $result;
01986             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01987                 $in = $ex.getInputStream ();
01988                 String _id = $ex.getId ();
01989                 throw new org.omg.CORBA.MARSHAL (_id);
01990             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01991                 return listDebugOptions (        );
01992             } finally {
01993                 _releaseReply ($in);
01994             }
01995   } // listDebugOptions
01996 
01997 
01998   //    void loadConfiguration();
01999   public void loadConfiguration (String filename) throws Sct_SctApi.SctApiException
02000   {
02001             org.omg.CORBA.portable.InputStream $in = null;
02002             try {
02003                 org.omg.CORBA.portable.OutputStream $out = _request ("loadConfiguration", true);
02004                 $out.write_string (filename);
02005                 $in = _invoke ($out);
02006                 return;
02007             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02008                 $in = $ex.getInputStream ();
02009                 String _id = $ex.getId ();
02010                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
02011                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
02012                 else
02013                     throw new org.omg.CORBA.MARSHAL (_id);
02014             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02015                 loadConfiguration (filename        );
02016             } finally {
02017                 _releaseReply ($in);
02018             }
02019   } // loadConfiguration
02020 
02021   public void rawData (int partition, int crate, int rod, int delay, int units, boolean setMask)
02022   {
02023             org.omg.CORBA.portable.InputStream $in = null;
02024             try {
02025                 org.omg.CORBA.portable.OutputStream $out = _request ("rawData", true);
02026                 $out.write_ulong (partition);
02027                 $out.write_ulong (crate);
02028                 $out.write_ulong (rod);
02029                 $out.write_long (delay);
02030                 $out.write_long (units);
02031                 $out.write_boolean (setMask);
02032                 $in = _invoke ($out);
02033                 return;
02034             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02035                 $in = $ex.getInputStream ();
02036                 String _id = $ex.getId ();
02037                 throw new org.omg.CORBA.MARSHAL (_id);
02038             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02039                 rawData (partition, crate, rod, delay, units, setMask        );
02040             } finally {
02041                 _releaseReply ($in);
02042             }
02043   } // rawData
02044 
02045   public void rawDataWithTrigger (int partition, int crate, int rod, int delay, int units, boolean setMask, Sct_SctApi.Trigger trig)
02046   {
02047             org.omg.CORBA.portable.InputStream $in = null;
02048             try {
02049                 org.omg.CORBA.portable.OutputStream $out = _request ("rawDataWithTrigger", true);
02050                 $out.write_ulong (partition);
02051                 $out.write_ulong (crate);
02052                 $out.write_ulong (rod);
02053                 $out.write_long (delay);
02054                 $out.write_long (units);
02055                 $out.write_boolean (setMask);
02056                 Sct_SctApi.TriggerHelper.write ($out, trig);
02057                 $in = _invoke ($out);
02058                 return;
02059             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02060                 $in = $ex.getInputStream ();
02061                 String _id = $ex.getId ();
02062                 throw new org.omg.CORBA.MARSHAL (_id);
02063             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02064                 rawDataWithTrigger (partition, crate, rod, delay, units, setMask, trig        );
02065             } finally {
02066                 _releaseReply ($in);
02067             }
02068   } // rawDataWithTrigger
02069 
02070   // Type-specific CORBA::Object operations
02071   private static String[] __ids = {
02072     "IDL:Sct_SctApi/SctApiIPC:1.0", 
02073     "IDL:ipc/servant:1.0", 
02074     "IDL:Sct_SctApi/JustCrateMethodsTemporary:1.0", 
02075     "IDL:Sct_SctApi/PrimitiveAccessLowLevel:1.0", 
02076     "IDL:Sct_SctApi/DebugSTDOUT:1.0", 
02077     "IDL:Sct_SctApi/OtherCrateLevel:1.0", 
02078     "IDL:Sct_SctApi/JustTopLevel:1.0", 
02079     "IDL:Sct_SctApi/CrateAccessTopLevel:1.0", 
02080     "IDL:Sct_SctApi/DebugOptionsJustTop:1.0", 
02081     "IDL:Sct_SctApi/JustTopLevelTemporary:1.0", 
02082     "IDL:Sct_SctApi/ScanMethods:1.0", 
02083     "IDL:Sct_SctApi/TranslationMethods:1.0", 
02084     "IDL:Sct_SctApi/CommonToTopAndCrate:1.0", 
02085     "IDL:Sct_SctApi/DoScanMethods:1.0", 
02086     "IDL:Sct_SctApi/ModifyABCDMethods:1.0", 
02087     "IDL:Sct_SctApi/ModuleConfigurationMethods:1.0", 
02088     "IDL:Sct_SctApi/RetrievingConfigurationMethods:1.0", 
02089     "IDL:Sct_SctApi/SavingConfigurationMethods:1.0", 
02090     "IDL:Sct_SctApi/TriggerRODLevel:1.0", 
02091     "IDL:Sct_SctApi/TriggerTIMLevel:1.0", 
02092     "IDL:Sct_SctApi/AutoConfigure:1.0", 
02093     "IDL:Sct_SctApi/ProbeChecks:1.0", 
02094     "IDL:Sct_SctApi/ProbeMethods:1.0", 
02095     "IDL:Sct_SctApi/RunControl:1.0", 
02096     "IDL:Sct_SctApi/ModuleInquiry:1.0", 
02097     "IDL:Sct_SctApi/DebugOptionsCommon:1.0", 
02098     "IDL:Sct_SctApi/DeprecatedInterfaceOne:1.0", 
02099     "IDL:Sct_SctApi/DeprecatedInterfaceTwo:1.0"};
02100 
02101   public String[] _ids ()
02102   {
02103     return (String[])__ids.clone ();
02104   }
02105 
02106   private void readObject (java.io.ObjectInputStream s) throws java.io.IOException
02107   {
02108      String str = s.readUTF ();
02109      String[] args = null;
02110      java.util.Properties props = null;
02111      org.omg.CORBA.Object obj = org.omg.CORBA.ORB.init (args, props).string_to_object (str);
02112      org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl) obj)._get_delegate ();
02113      _set_delegate (delegate);
02114   }
02115 
02116   private void writeObject (java.io.ObjectOutputStream s) throws java.io.IOException
02117   {
02118      String[] args = null;
02119      java.util.Properties props = null;
02120      String str = org.omg.CORBA.ORB.init (args, props).object_to_string (this);
02121      s.writeUTF (str);
02122   }
02123 } // class _SctApiIPCStub

Generated on Fri Sep 16 18:05:52 2005 for SCT DAQ/DCS Software - Java by doxygen 1.3.5