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

_SctApiStub.java

00001 package Sct_SctApi;
00002 
00003 
00011 public class _SctApiStub extends org.omg.CORBA.portable.ObjectImpl implements Sct_SctApi.SctApi
00012 {
00013 
00014   public void initialiseAll (int runNumber) throws Sct_SctApi.SctApiException
00015   {
00016             org.omg.CORBA.portable.InputStream $in = null;
00017             try {
00018                 org.omg.CORBA.portable.OutputStream $out = _request ("initialiseAll", true);
00019                 $out.write_ulong (runNumber);
00020                 $in = _invoke ($out);
00021                 return;
00022             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00023                 $in = $ex.getInputStream ();
00024                 String _id = $ex.getId ();
00025                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00026                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00027                 else
00028                     throw new org.omg.CORBA.MARSHAL (_id);
00029             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00030                 initialiseAll (runNumber        );
00031             } finally {
00032                 _releaseReply ($in);
00033             }
00034   } // initialiseAll
00035 
00036   public void shutdownAll () throws Sct_SctApi.SctApiException
00037   {
00038             org.omg.CORBA.portable.InputStream $in = null;
00039             try {
00040                 org.omg.CORBA.portable.OutputStream $out = _request ("shutdownAll", true);
00041                 $in = _invoke ($out);
00042                 return;
00043             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00044                 $in = $ex.getInputStream ();
00045                 String _id = $ex.getId ();
00046                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00047                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00048                 else
00049                     throw new org.omg.CORBA.MARSHAL (_id);
00050             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00051                 shutdownAll (        );
00052             } finally {
00053                 _releaseReply ($in);
00054             }
00055   } // shutdownAll
00056 
00057   public void status ()
00058   {
00059             org.omg.CORBA.portable.InputStream $in = null;
00060             try {
00061                 org.omg.CORBA.portable.OutputStream $out = _request ("status", true);
00062                 $in = _invoke ($out);
00063                 return;
00064             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00065                 $in = $ex.getInputStream ();
00066                 String _id = $ex.getId ();
00067                 throw new org.omg.CORBA.MARSHAL (_id);
00068             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00069                 status (        );
00070             } finally {
00071                 _releaseReply ($in);
00072             }
00073   } // status
00074 
00075   public void setRunNumber (int newRun)
00076   {
00077             org.omg.CORBA.portable.InputStream $in = null;
00078             try {
00079                 org.omg.CORBA.portable.OutputStream $out = _request ("setRunNumber", true);
00080                 $out.write_ulong (newRun);
00081                 $in = _invoke ($out);
00082                 return;
00083             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00084                 $in = $ex.getInputStream ();
00085                 String _id = $ex.getId ();
00086                 throw new org.omg.CORBA.MARSHAL (_id);
00087             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00088                 setRunNumber (newRun        );
00089             } finally {
00090                 _releaseReply ($in);
00091             }
00092   } // setRunNumber
00093 
00094   public void setScanNumber (int newScan)
00095   {
00096             org.omg.CORBA.portable.InputStream $in = null;
00097             try {
00098                 org.omg.CORBA.portable.OutputStream $out = _request ("setScanNumber", true);
00099                 $out.write_ulong (newScan);
00100                 $in = _invoke ($out);
00101                 return;
00102             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00103                 $in = $ex.getInputStream ();
00104                 String _id = $ex.getId ();
00105                 throw new org.omg.CORBA.MARSHAL (_id);
00106             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00107                 setScanNumber (newScan        );
00108             } finally {
00109                 _releaseReply ($in);
00110             }
00111   } // setScanNumber
00112 
00113   public int getRunNumber ()
00114   {
00115             org.omg.CORBA.portable.InputStream $in = null;
00116             try {
00117                 org.omg.CORBA.portable.OutputStream $out = _request ("getRunNumber", true);
00118                 $in = _invoke ($out);
00119                 int $result = $in.read_ulong ();
00120                 return $result;
00121             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00122                 $in = $ex.getInputStream ();
00123                 String _id = $ex.getId ();
00124                 throw new org.omg.CORBA.MARSHAL (_id);
00125             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00126                 return getRunNumber (        );
00127             } finally {
00128                 _releaseReply ($in);
00129             }
00130   } // getRunNumber
00131 
00132   public int getScanNumber ()
00133   {
00134             org.omg.CORBA.portable.InputStream $in = null;
00135             try {
00136                 org.omg.CORBA.portable.OutputStream $out = _request ("getScanNumber", true);
00137                 $in = _invoke ($out);
00138                 int $result = $in.read_ulong ();
00139                 return $result;
00140             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00141                 $in = $ex.getInputStream ();
00142                 String _id = $ex.getId ();
00143                 throw new org.omg.CORBA.MARSHAL (_id);
00144             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00145                 return getScanNumber (        );
00146             } finally {
00147                 _releaseReply ($in);
00148             }
00149   } // getScanNumber
00150 
00151   public void unsetDebugOption (String opt)
00152   {
00153             org.omg.CORBA.portable.InputStream $in = null;
00154             try {
00155                 org.omg.CORBA.portable.OutputStream $out = _request ("unsetDebugOption", true);
00156                 $out.write_string (opt);
00157                 $in = _invoke ($out);
00158                 return;
00159             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00160                 $in = $ex.getInputStream ();
00161                 String _id = $ex.getId ();
00162                 throw new org.omg.CORBA.MARSHAL (_id);
00163             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00164                 unsetDebugOption (opt        );
00165             } finally {
00166                 _releaseReply ($in);
00167             }
00168   } // unsetDebugOption
00169 
00170   public void setDebugOption (String opt)
00171   {
00172             org.omg.CORBA.portable.InputStream $in = null;
00173             try {
00174                 org.omg.CORBA.portable.OutputStream $out = _request ("setDebugOption", true);
00175                 $out.write_string (opt);
00176                 $in = _invoke ($out);
00177                 return;
00178             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00179                 $in = $ex.getInputStream ();
00180                 String _id = $ex.getId ();
00181                 throw new org.omg.CORBA.MARSHAL (_id);
00182             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00183                 setDebugOption (opt        );
00184             } finally {
00185                 _releaseReply ($in);
00186             }
00187   } // setDebugOption
00188 
00189   public String[] listEnabledDebugOptions ()
00190   {
00191             org.omg.CORBA.portable.InputStream $in = null;
00192             try {
00193                 org.omg.CORBA.portable.OutputStream $out = _request ("listEnabledDebugOptions", true);
00194                 $in = _invoke ($out);
00195                 String $result[] = Sct_SctApi.DefectListHelper.read ($in);
00196                 return $result;
00197             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00198                 $in = $ex.getInputStream ();
00199                 String _id = $ex.getId ();
00200                 throw new org.omg.CORBA.MARSHAL (_id);
00201             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00202                 return listEnabledDebugOptions (        );
00203             } finally {
00204                 _releaseReply ($in);
00205             }
00206   } // listEnabledDebugOptions
00207 
00208   public String[] listDebugOptions ()
00209   {
00210             org.omg.CORBA.portable.InputStream $in = null;
00211             try {
00212                 org.omg.CORBA.portable.OutputStream $out = _request ("listDebugOptions", true);
00213                 $in = _invoke ($out);
00214                 String $result[] = Sct_SctApi.DefectListHelper.read ($in);
00215                 return $result;
00216             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00217                 $in = $ex.getInputStream ();
00218                 String _id = $ex.getId ();
00219                 throw new org.omg.CORBA.MARSHAL (_id);
00220             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00221                 return listDebugOptions (        );
00222             } finally {
00223                 _releaseReply ($in);
00224             }
00225   } // listDebugOptions
00226 
00227   public void standardRegisterDump (int partition, int crate, int rod)
00228   {
00229             org.omg.CORBA.portable.InputStream $in = null;
00230             try {
00231                 org.omg.CORBA.portable.OutputStream $out = _request ("standardRegisterDump", true);
00232                 $out.write_ulong (partition);
00233                 $out.write_ulong (crate);
00234                 $out.write_ulong (rod);
00235                 $in = _invoke ($out);
00236                 return;
00237             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00238                 $in = $ex.getInputStream ();
00239                 String _id = $ex.getId ();
00240                 throw new org.omg.CORBA.MARSHAL (_id);
00241             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00242                 standardRegisterDump (partition, crate, rod        );
00243             } finally {
00244                 _releaseReply ($in);
00245             }
00246   } // standardRegisterDump
00247 
00248   public void standardRegisterDumpAll ()
00249   {
00250             org.omg.CORBA.portable.InputStream $in = null;
00251             try {
00252                 org.omg.CORBA.portable.OutputStream $out = _request ("standardRegisterDumpAll", true);
00253                 $in = _invoke ($out);
00254                 return;
00255             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00256                 $in = $ex.getInputStream ();
00257                 String _id = $ex.getId ();
00258                 throw new org.omg.CORBA.MARSHAL (_id);
00259             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00260                 standardRegisterDumpAll (        );
00261             } finally {
00262                 _releaseReply ($in);
00263             }
00264   } // standardRegisterDumpAll
00265 
00266   public String[] getModuleList ()
00267   {
00268             org.omg.CORBA.portable.InputStream $in = null;
00269             try {
00270                 org.omg.CORBA.portable.OutputStream $out = _request ("getModuleList", true);
00271                 $in = _invoke ($out);
00272                 String $result[] = sctConf.ModuleListHelper.read ($in);
00273                 return $result;
00274             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00275                 $in = $ex.getInputStream ();
00276                 String _id = $ex.getId ();
00277                 throw new org.omg.CORBA.MARSHAL (_id);
00278             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00279                 return getModuleList (        );
00280             } finally {
00281                 _releaseReply ($in);
00282             }
00283   } // getModuleList
00284 
00285   public boolean isRODPresent (int partition, int crate, int rod)
00286   {
00287             org.omg.CORBA.portable.InputStream $in = null;
00288             try {
00289                 org.omg.CORBA.portable.OutputStream $out = _request ("isRODPresent", true);
00290                 $out.write_ulong (partition);
00291                 $out.write_ulong (crate);
00292                 $out.write_ulong (rod);
00293                 $in = _invoke ($out);
00294                 boolean $result = $in.read_boolean ();
00295                 return $result;
00296             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00297                 $in = $ex.getInputStream ();
00298                 String _id = $ex.getId ();
00299                 throw new org.omg.CORBA.MARSHAL (_id);
00300             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00301                 return isRODPresent (partition, crate, rod        );
00302             } finally {
00303                 _releaseReply ($in);
00304             }
00305   } // isRODPresent
00306 
00307   public void awaitResponse (int partition, int crate, int rod)
00308   {
00309             org.omg.CORBA.portable.InputStream $in = null;
00310             try {
00311                 org.omg.CORBA.portable.OutputStream $out = _request ("awaitResponse", true);
00312                 $out.write_ulong (partition);
00313                 $out.write_ulong (crate);
00314                 $out.write_ulong (rod);
00315                 $in = _invoke ($out);
00316                 return;
00317             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00318                 $in = $ex.getInputStream ();
00319                 String _id = $ex.getId ();
00320                 throw new org.omg.CORBA.MARSHAL (_id);
00321             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00322                 awaitResponse (partition, crate, rod        );
00323             } finally {
00324                 _releaseReply ($in);
00325             }
00326   } // awaitResponse
00327 
00328   public int[] getResponse (int partition, int crate, int rod)
00329   {
00330             org.omg.CORBA.portable.InputStream $in = null;
00331             try {
00332                 org.omg.CORBA.portable.OutputStream $out = _request ("getResponse", true);
00333                 $out.write_ulong (partition);
00334                 $out.write_ulong (crate);
00335                 $out.write_ulong (rod);
00336                 $in = _invoke ($out);
00337                 int $result[] = Sct_SctApi.DataBlockHelper.read ($in);
00338                 return $result;
00339             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00340                 $in = $ex.getInputStream ();
00341                 String _id = $ex.getId ();
00342                 throw new org.omg.CORBA.MARSHAL (_id);
00343             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00344                 return getResponse (partition, crate, rod        );
00345             } finally {
00346                 _releaseReply ($in);
00347             }
00348   } // getResponse
00349 
00350   public void configureBOC (int partition, int crate, int rod)
00351   {
00352             org.omg.CORBA.portable.InputStream $in = null;
00353             try {
00354                 org.omg.CORBA.portable.OutputStream $out = _request ("configureBOC", true);
00355                 $out.write_ulong (partition);
00356                 $out.write_ulong (crate);
00357                 $out.write_ulong (rod);
00358                 $in = _invoke ($out);
00359                 return;
00360             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00361                 $in = $ex.getInputStream ();
00362                 String _id = $ex.getId ();
00363                 throw new org.omg.CORBA.MARSHAL (_id);
00364             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00365                 configureBOC (partition, crate, rod        );
00366             } finally {
00367                 _releaseReply ($in);
00368             }
00369   } // configureBOC
00370 
00371   public double[] getBOCMonitorArray (int partition, int crate, int rod)
00372   {
00373             org.omg.CORBA.portable.InputStream $in = null;
00374             try {
00375                 org.omg.CORBA.portable.OutputStream $out = _request ("getBOCMonitorArray", true);
00376                 $out.write_ulong (partition);
00377                 $out.write_ulong (crate);
00378                 $out.write_ulong (rod);
00379                 $in = _invoke ($out);
00380                 double $result[] = Sct_SctApi.BOCMonitorSequenceHelper.read ($in);
00381                 return $result;
00382             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00383                 $in = $ex.getInputStream ();
00384                 String _id = $ex.getId ();
00385                 throw new org.omg.CORBA.MARSHAL (_id);
00386             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00387                 return getBOCMonitorArray (partition, crate, rod        );
00388             } finally {
00389                 _releaseReply ($in);
00390             }
00391   } // getBOCMonitorArray
00392 
00393   public void flashLED (int partition, int crate, int rod, short slaveNumber, int period, int flashes) throws Sct_SctApi.SctApiException
00394   {
00395             org.omg.CORBA.portable.InputStream $in = null;
00396             try {
00397                 org.omg.CORBA.portable.OutputStream $out = _request ("flashLED", true);
00398                 $out.write_ulong (partition);
00399                 $out.write_ulong (crate);
00400                 $out.write_ulong (rod);
00401                 $out.write_ushort (slaveNumber);
00402                 $out.write_ulong (period);
00403                 $out.write_ulong (flashes);
00404                 $in = _invoke ($out);
00405                 return;
00406             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00407                 $in = $ex.getInputStream ();
00408                 String _id = $ex.getId ();
00409                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00410                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00411                 else
00412                     throw new org.omg.CORBA.MARSHAL (_id);
00413             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00414                 flashLED (partition, crate, rod, slaveNumber, period, flashes        );
00415             } finally {
00416                 _releaseReply ($in);
00417             }
00418   } // flashLED
00419 
00420   public void echo (int partition, int crate, int rod, int[] data) throws Sct_SctApi.SctApiException
00421   {
00422             org.omg.CORBA.portable.InputStream $in = null;
00423             try {
00424                 org.omg.CORBA.portable.OutputStream $out = _request ("echo", true);
00425                 $out.write_ulong (partition);
00426                 $out.write_ulong (crate);
00427                 $out.write_ulong (rod);
00428                 Sct_SctApi.DataBlockHelper.write ($out, data);
00429                 $in = _invoke ($out);
00430                 return;
00431             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00432                 $in = $ex.getInputStream ();
00433                 String _id = $ex.getId ();
00434                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00435                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00436                 else
00437                     throw new org.omg.CORBA.MARSHAL (_id);
00438             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00439                 echo (partition, crate, rod, data        );
00440             } finally {
00441                 _releaseReply ($in);
00442             }
00443   } // echo
00444 
00445   public void createDebugPrimList () throws Sct_SctApi.SctApiException
00446   {
00447             org.omg.CORBA.portable.InputStream $in = null;
00448             try {
00449                 org.omg.CORBA.portable.OutputStream $out = _request ("createDebugPrimList", true);
00450                 $in = _invoke ($out);
00451                 return;
00452             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00453                 $in = $ex.getInputStream ();
00454                 String _id = $ex.getId ();
00455                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00456                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00457                 else
00458                     throw new org.omg.CORBA.MARSHAL (_id);
00459             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00460                 createDebugPrimList (        );
00461             } finally {
00462                 _releaseReply ($in);
00463             }
00464   } // createDebugPrimList
00465 
00466   public void addDebugPrimList (int index, int id, int version, int[] body) throws Sct_SctApi.SctApiException
00467   {
00468             org.omg.CORBA.portable.InputStream $in = null;
00469             try {
00470                 org.omg.CORBA.portable.OutputStream $out = _request ("addDebugPrimList", true);
00471                 $out.write_long (index);
00472                 $out.write_long (id);
00473                 $out.write_long (version);
00474                 Sct_SctApi.DataBlockHelper.write ($out, body);
00475                 $in = _invoke ($out);
00476                 return;
00477             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00478                 $in = $ex.getInputStream ();
00479                 String _id = $ex.getId ();
00480                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00481                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00482                 else
00483                     throw new org.omg.CORBA.MARSHAL (_id);
00484             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00485                 addDebugPrimList (index, id, version, body        );
00486             } finally {
00487                 _releaseReply ($in);
00488             }
00489   } // addDebugPrimList
00490 
00491   public void sendDebugPrimList (int partition, int crate, int rod) throws Sct_SctApi.SctApiException
00492   {
00493             org.omg.CORBA.portable.InputStream $in = null;
00494             try {
00495                 org.omg.CORBA.portable.OutputStream $out = _request ("sendDebugPrimList", true);
00496                 $out.write_ulong (partition);
00497                 $out.write_ulong (crate);
00498                 $out.write_ulong (rod);
00499                 $in = _invoke ($out);
00500                 return;
00501             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00502                 $in = $ex.getInputStream ();
00503                 String _id = $ex.getId ();
00504                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00505                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00506                 else
00507                     throw new org.omg.CORBA.MARSHAL (_id);
00508             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00509                 sendDebugPrimList (partition, crate, rod        );
00510             } finally {
00511                 _releaseReply ($in);
00512             }
00513   } // sendDebugPrimList
00514 
00515   public void sendDebugSlavePrimList (int partition, int crate, int rod, int slave, boolean await, boolean response) throws Sct_SctApi.SctApiException
00516   {
00517             org.omg.CORBA.portable.InputStream $in = null;
00518             try {
00519                 org.omg.CORBA.portable.OutputStream $out = _request ("sendDebugSlavePrimList", true);
00520                 $out.write_ulong (partition);
00521                 $out.write_ulong (crate);
00522                 $out.write_ulong (rod);
00523                 $out.write_ulong (slave);
00524                 $out.write_boolean (await);
00525                 $out.write_boolean (response);
00526                 $in = _invoke ($out);
00527                 return;
00528             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00529                 $in = $ex.getInputStream ();
00530                 String _id = $ex.getId ();
00531                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00532                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00533                 else
00534                     throw new org.omg.CORBA.MARSHAL (_id);
00535             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00536                 sendDebugSlavePrimList (partition, crate, rod, slave, await, response        );
00537             } finally {
00538                 _releaseReply ($in);
00539             }
00540   } // sendDebugSlavePrimList
00541 
00542 
00543   //    void loadConfiguration();
00544   public void loadConfiguration (String filename) throws Sct_SctApi.SctApiException
00545   {
00546             org.omg.CORBA.portable.InputStream $in = null;
00547             try {
00548                 org.omg.CORBA.portable.OutputStream $out = _request ("loadConfiguration", true);
00549                 $out.write_string (filename);
00550                 $in = _invoke ($out);
00551                 return;
00552             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00553                 $in = $ex.getInputStream ();
00554                 String _id = $ex.getId ();
00555                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00556                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00557                 else
00558                     throw new org.omg.CORBA.MARSHAL (_id);
00559             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00560                 loadConfiguration (filename        );
00561             } finally {
00562                 _releaseReply ($in);
00563             }
00564   } // loadConfiguration
00565 
00566   public void storeModuleConfigurations () throws Sct_SctApi.SctApiException
00567   {
00568             org.omg.CORBA.portable.InputStream $in = null;
00569             try {
00570                 org.omg.CORBA.portable.OutputStream $out = _request ("storeModuleConfigurations", true);
00571                 $in = _invoke ($out);
00572                 return;
00573             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00574                 $in = $ex.getInputStream ();
00575                 String _id = $ex.getId ();
00576                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00577                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00578                 else
00579                     throw new org.omg.CORBA.MARSHAL (_id);
00580             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00581                 storeModuleConfigurations (        );
00582             } finally {
00583                 _releaseReply ($in);
00584             }
00585   } // storeModuleConfigurations
00586 
00587   public void configureAllModules () throws Sct_SctApi.SctApiException
00588   {
00589             org.omg.CORBA.portable.InputStream $in = null;
00590             try {
00591                 org.omg.CORBA.portable.OutputStream $out = _request ("configureAllModules", true);
00592                 $in = _invoke ($out);
00593                 return;
00594             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00595                 $in = $ex.getInputStream ();
00596                 String _id = $ex.getId ();
00597                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00598                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00599                 else
00600                     throw new org.omg.CORBA.MARSHAL (_id);
00601             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00602                 configureAllModules (        );
00603             } finally {
00604                 _releaseReply ($in);
00605             }
00606   } // configureAllModules
00607 
00608 
00610   public sctConf.ABCDModule retrieveModule (int mid)
00611   {
00612             org.omg.CORBA.portable.InputStream $in = null;
00613             try {
00614                 org.omg.CORBA.portable.OutputStream $out = _request ("retrieveModule", true);
00615                 $out.write_ulong (mid);
00616                 $in = _invoke ($out);
00617                 sctConf.ABCDModule $result = sctConf.ABCDModuleHelper.read ($in);
00618                 return $result;
00619             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00620                 $in = $ex.getInputStream ();
00621                 String _id = $ex.getId ();
00622                 throw new org.omg.CORBA.MARSHAL (_id);
00623             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00624                 return retrieveModule (mid        );
00625             } finally {
00626                 _releaseReply ($in);
00627             }
00628   } // retrieveModule
00629 
00630 
00631   /***************** Direct ROD access (Debug only) ********************/
00632   public short dspBlockDump (int partition, int crate, int rod, int dspStart, int numWords, int dspNumber)
00633   {
00634             org.omg.CORBA.portable.InputStream $in = null;
00635             try {
00636                 org.omg.CORBA.portable.OutputStream $out = _request ("dspBlockDump", true);
00637                 $out.write_ulong (partition);
00638                 $out.write_ulong (crate);
00639                 $out.write_ulong (rod);
00640                 $out.write_long (dspStart);
00641                 $out.write_long (numWords);
00642                 $out.write_long (dspNumber);
00643                 $in = _invoke ($out);
00644                 short $result = $in.read_short ();
00645                 return $result;
00646             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00647                 $in = $ex.getInputStream ();
00648                 String _id = $ex.getId ();
00649                 throw new org.omg.CORBA.MARSHAL (_id);
00650             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00651                 return dspBlockDump (partition, crate, rod, dspStart, numWords, dspNumber        );
00652             } finally {
00653                 _releaseReply ($in);
00654             }
00655   } // dspBlockDump
00656 
00657   public int[] dspBlockRead (int partition, int crate, int rod, int dspStart, int numWords, int dspNumber)
00658   {
00659             org.omg.CORBA.portable.InputStream $in = null;
00660             try {
00661                 org.omg.CORBA.portable.OutputStream $out = _request ("dspBlockRead", true);
00662                 $out.write_ulong (partition);
00663                 $out.write_ulong (crate);
00664                 $out.write_ulong (rod);
00665                 $out.write_long (dspStart);
00666                 $out.write_long (numWords);
00667                 $out.write_long (dspNumber);
00668                 $in = _invoke ($out);
00669                 int $result[] = Sct_SctApi.DataBlockHelper.read ($in);
00670                 return $result;
00671             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00672                 $in = $ex.getInputStream ();
00673                 String _id = $ex.getId ();
00674                 throw new org.omg.CORBA.MARSHAL (_id);
00675             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00676                 return dspBlockRead (partition, crate, rod, dspStart, numWords, dspNumber        );
00677             } finally {
00678                 _releaseReply ($in);
00679             }
00680   } // dspBlockRead
00681 
00682   public short dspBlockWrite (int partition, int crate, int rod, int[] buffer, int dspAddress, int dspNumber)
00683   {
00684             org.omg.CORBA.portable.InputStream $in = null;
00685             try {
00686                 org.omg.CORBA.portable.OutputStream $out = _request ("dspBlockWrite", true);
00687                 $out.write_ulong (partition);
00688                 $out.write_ulong (crate);
00689                 $out.write_ulong (rod);
00690                 Sct_SctApi.DataBlockHelper.write ($out, buffer);
00691                 $out.write_ulong (dspAddress);
00692                 $out.write_long (dspNumber);
00693                 $in = _invoke ($out);
00694                 short $result = $in.read_short ();
00695                 return $result;
00696             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00697                 $in = $ex.getInputStream ();
00698                 String _id = $ex.getId ();
00699                 throw new org.omg.CORBA.MARSHAL (_id);
00700             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00701                 return dspBlockWrite (partition, crate, rod, buffer, dspAddress, dspNumber        );
00702             } finally {
00703                 _releaseReply ($in);
00704             }
00705   } // dspBlockWrite
00706 
00707   public int dspSingleRead (int partition, int crate, int rod, int dspAddr, int dspNumber)
00708   {
00709             org.omg.CORBA.portable.InputStream $in = null;
00710             try {
00711                 org.omg.CORBA.portable.OutputStream $out = _request ("dspSingleRead", true);
00712                 $out.write_ulong (partition);
00713                 $out.write_ulong (crate);
00714                 $out.write_ulong (rod);
00715                 $out.write_ulong (dspAddr);
00716                 $out.write_long (dspNumber);
00717                 $in = _invoke ($out);
00718                 int $result = $in.read_ulong ();
00719                 return $result;
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                 return dspSingleRead (partition, crate, rod, dspAddr, dspNumber        );
00726             } finally {
00727                 _releaseReply ($in);
00728             }
00729   } // dspSingleRead
00730 
00731   public void dspSingleWrite (int partition, int crate, int rod, int dspAddr, int val, int dspNumber)
00732   {
00733             org.omg.CORBA.portable.InputStream $in = null;
00734             try {
00735                 org.omg.CORBA.portable.OutputStream $out = _request ("dspSingleWrite", true);
00736                 $out.write_ulong (partition);
00737                 $out.write_ulong (crate);
00738                 $out.write_ulong (rod);
00739                 $out.write_ulong (dspAddr);
00740                 $out.write_ulong (val);
00741                 $out.write_long (dspNumber);
00742                 $in = _invoke ($out);
00743                 return;
00744             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00745                 $in = $ex.getInputStream ();
00746                 String _id = $ex.getId ();
00747                 throw new org.omg.CORBA.MARSHAL (_id);
00748             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00749                 dspSingleWrite (partition, crate, rod, dspAddr, val, dspNumber        );
00750             } finally {
00751                 _releaseReply ($in);
00752             }
00753   } // dspSingleWrite
00754 
00755   public int[] readSlaveDsp (int partition, int crate, int rod, short s, int add, int words)
00756   {
00757             org.omg.CORBA.portable.InputStream $in = null;
00758             try {
00759                 org.omg.CORBA.portable.OutputStream $out = _request ("readSlaveDsp", true);
00760                 $out.write_ulong (partition);
00761                 $out.write_ulong (crate);
00762                 $out.write_ulong (rod);
00763                 $out.write_short (s);
00764                 $out.write_ulong (add);
00765                 $out.write_ulong (words);
00766                 $in = _invoke ($out);
00767                 int $result[] = Sct_SctApi.DataBlockHelper.read ($in);
00768                 return $result;
00769             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00770                 $in = $ex.getInputStream ();
00771                 String _id = $ex.getId ();
00772                 throw new org.omg.CORBA.MARSHAL (_id);
00773             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00774                 return readSlaveDsp (partition, crate, rod, s, add, words        );
00775             } finally {
00776                 _releaseReply ($in);
00777             }
00778   } // readSlaveDsp
00779 
00780 
00781   // Translation
00782   public int findModuleSerial (String sn)
00783   {
00784             org.omg.CORBA.portable.InputStream $in = null;
00785             try {
00786                 org.omg.CORBA.portable.OutputStream $out = _request ("findModuleSerial", true);
00787                 $out.write_string (sn);
00788                 $in = _invoke ($out);
00789                 int $result = $in.read_ulong ();
00790                 return $result;
00791             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00792                 $in = $ex.getInputStream ();
00793                 String _id = $ex.getId ();
00794                 throw new org.omg.CORBA.MARSHAL (_id);
00795             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00796                 return findModuleSerial (sn        );
00797             } finally {
00798                 _releaseReply ($in);
00799             }
00800   } // findModuleSerial
00801 
00802   public String convertToString (int mid)
00803   {
00804             org.omg.CORBA.portable.InputStream $in = null;
00805             try {
00806                 org.omg.CORBA.portable.OutputStream $out = _request ("convertToString", true);
00807                 $out.write_ulong (mid);
00808                 $in = _invoke ($out);
00809                 String $result = $in.read_string ();
00810                 return $result;
00811             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00812                 $in = $ex.getInputStream ();
00813                 String _id = $ex.getId ();
00814                 throw new org.omg.CORBA.MARSHAL (_id);
00815             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00816                 return convertToString (mid        );
00817             } finally {
00818                 _releaseReply ($in);
00819             }
00820   } // convertToString
00821 
00822   public int findModule (short mur, short number)
00823   {
00824             org.omg.CORBA.portable.InputStream $in = null;
00825             try {
00826                 org.omg.CORBA.portable.OutputStream $out = _request ("findModule", true);
00827                 $out.write_ushort (mur);
00828                 $out.write_ushort (number);
00829                 $in = _invoke ($out);
00830                 int $result = $in.read_ulong ();
00831                 return $result;
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                 return findModule (mur, number        );
00838             } finally {
00839                 _releaseReply ($in);
00840             }
00841   } // findModule
00842 
00843   public int findModuleRod (int partition, int crate, int rod, int channel)
00844   {
00845             org.omg.CORBA.portable.InputStream $in = null;
00846             try {
00847                 org.omg.CORBA.portable.OutputStream $out = _request ("findModuleRod", true);
00848                 $out.write_ulong (partition);
00849                 $out.write_ulong (crate);
00850                 $out.write_ulong (rod);
00851                 $out.write_ulong (channel);
00852                 $in = _invoke ($out);
00853                 int $result = $in.read_ulong ();
00854                 return $result;
00855             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00856                 $in = $ex.getInputStream ();
00857                 String _id = $ex.getId ();
00858                 throw new org.omg.CORBA.MARSHAL (_id);
00859             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00860                 return findModuleRod (partition, crate, rod, channel        );
00861             } finally {
00862                 _releaseReply ($in);
00863             }
00864   } // findModuleRod
00865 
00866 
00867   //  pair<INT32, INT32> convertToMUR(in unsigned long mid);
00868   public int findBarrelModule (int barrel, int row, short number)
00869   {
00870             org.omg.CORBA.portable.InputStream $in = null;
00871             try {
00872                 org.omg.CORBA.portable.OutputStream $out = _request ("findBarrelModule", true);
00873                 $out.write_ulong (barrel);
00874                 $out.write_ulong (row);
00875                 $out.write_short (number);
00876                 $in = _invoke ($out);
00877                 int $result = $in.read_ulong ();
00878                 return $result;
00879             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00880                 $in = $ex.getInputStream ();
00881                 String _id = $ex.getId ();
00882                 throw new org.omg.CORBA.MARSHAL (_id);
00883             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00884                 return findBarrelModule (barrel, row, number        );
00885             } finally {
00886                 _releaseReply ($in);
00887             }
00888   } // findBarrelModule
00889 
00890   public void convertToBarrelModule (int mid, org.omg.CORBA.IntHolder barrel, org.omg.CORBA.IntHolder row, org.omg.CORBA.ShortHolder number)
00891   {
00892             org.omg.CORBA.portable.InputStream $in = null;
00893             try {
00894                 org.omg.CORBA.portable.OutputStream $out = _request ("convertToBarrelModule", true);
00895                 $out.write_ulong (mid);
00896                 $in = _invoke ($out);
00897                 barrel.value = $in.read_ulong ();
00898                 row.value = $in.read_ulong ();
00899                 number.value = $in.read_short ();
00900                 return;
00901             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00902                 $in = $ex.getInputStream ();
00903                 String _id = $ex.getId ();
00904                 throw new org.omg.CORBA.MARSHAL (_id);
00905             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00906                 convertToBarrelModule (mid, barrel, row, number        );
00907             } finally {
00908                 _releaseReply ($in);
00909             }
00910   } // convertToBarrelModule
00911 
00912   public int findEndcapModule (int disk, int ring, int number)
00913   {
00914             org.omg.CORBA.portable.InputStream $in = null;
00915             try {
00916                 org.omg.CORBA.portable.OutputStream $out = _request ("findEndcapModule", true);
00917                 $out.write_long (disk);
00918                 $out.write_long (ring);
00919                 $out.write_long (number);
00920                 $in = _invoke ($out);
00921                 int $result = $in.read_ulong ();
00922                 return $result;
00923             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00924                 $in = $ex.getInputStream ();
00925                 String _id = $ex.getId ();
00926                 throw new org.omg.CORBA.MARSHAL (_id);
00927             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00928                 return findEndcapModule (disk, ring, number        );
00929             } finally {
00930                 _releaseReply ($in);
00931             }
00932   } // findEndcapModule
00933 
00934   public void convertToEndcapModule (int mid, org.omg.CORBA.IntHolder disk, org.omg.CORBA.IntHolder ring, org.omg.CORBA.IntHolder number)
00935   {
00936             org.omg.CORBA.portable.InputStream $in = null;
00937             try {
00938                 org.omg.CORBA.portable.OutputStream $out = _request ("convertToEndcapModule", true);
00939                 $out.write_ulong (mid);
00940                 $in = _invoke ($out);
00941                 disk.value = $in.read_long ();
00942                 ring.value = $in.read_ulong ();
00943                 number.value = $in.read_ulong ();
00944                 return;
00945             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00946                 $in = $ex.getInputStream ();
00947                 String _id = $ex.getId ();
00948                 throw new org.omg.CORBA.MARSHAL (_id);
00949             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00950                 convertToEndcapModule (mid, disk, ring, number        );
00951             } finally {
00952                 _releaseReply ($in);
00953             }
00954   } // convertToEndcapModule
00955 
00956 
00958   public void getABCDModules (Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
00959   {
00960             org.omg.CORBA.portable.InputStream $in = null;
00961             try {
00962                 org.omg.CORBA.portable.OutputStream $out = _request ("getABCDModules", true);
00963                 Sct_SctApi.BankTypeHelper.write ($out, bank);
00964                 $in = _invoke ($out);
00965                 return;
00966             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00967                 $in = $ex.getInputStream ();
00968                 String _id = $ex.getId ();
00969                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00970                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00971                 else
00972                     throw new org.omg.CORBA.MARSHAL (_id);
00973             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00974                 getABCDModules (bank        );
00975             } finally {
00976                 _releaseReply ($in);
00977             }
00978   } // getABCDModules
00979 
00980   public void getABCDModule (int mid, Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
00981   {
00982             org.omg.CORBA.portable.InputStream $in = null;
00983             try {
00984                 org.omg.CORBA.portable.OutputStream $out = _request ("getABCDModule", true);
00985                 $out.write_ulong (mid);
00986                 Sct_SctApi.BankTypeHelper.write ($out, bank);
00987                 $in = _invoke ($out);
00988                 return;
00989             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00990                 $in = $ex.getInputStream ();
00991                 String _id = $ex.getId ();
00992                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
00993                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
00994                 else
00995                     throw new org.omg.CORBA.MARSHAL (_id);
00996             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00997                 getABCDModule (mid, bank        );
00998             } finally {
00999                 _releaseReply ($in);
01000             }
01001   } // getABCDModule
01002 
01003   public sctConf.ABCDModule getABCDModuleRaw (int partition, int crate, int rod, int slot, Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
01004   {
01005             org.omg.CORBA.portable.InputStream $in = null;
01006             try {
01007                 org.omg.CORBA.portable.OutputStream $out = _request ("getABCDModuleRaw", true);
01008                 $out.write_ulong (partition);
01009                 $out.write_ulong (crate);
01010                 $out.write_ulong (rod);
01011                 $out.write_ulong (slot);
01012                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01013                 $in = _invoke ($out);
01014                 sctConf.ABCDModule $result = sctConf.ABCDModuleHelper.read ($in);
01015                 return $result;
01016             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01017                 $in = $ex.getInputStream ();
01018                 String _id = $ex.getId ();
01019                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01020                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01021                 else
01022                     throw new org.omg.CORBA.MARSHAL (_id);
01023             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01024                 return getABCDModuleRaw (partition, crate, rod, slot, bank        );
01025             } finally {
01026                 _releaseReply ($in);
01027             }
01028   } // getABCDModuleRaw
01029 
01030   public void setABCDModule (int mid, Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
01031   {
01032             org.omg.CORBA.portable.InputStream $in = null;
01033             try {
01034                 org.omg.CORBA.portable.OutputStream $out = _request ("setABCDModule", true);
01035                 $out.write_ulong (mid);
01036                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01037                 $in = _invoke ($out);
01038                 return;
01039             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01040                 $in = $ex.getInputStream ();
01041                 String _id = $ex.getId ();
01042                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01043                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01044                 else
01045                     throw new org.omg.CORBA.MARSHAL (_id);
01046             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01047                 setABCDModule (mid, bank        );
01048             } finally {
01049                 _releaseReply ($in);
01050             }
01051   } // setABCDModule
01052 
01053   public void setABCDModules (Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
01054   {
01055             org.omg.CORBA.portable.InputStream $in = null;
01056             try {
01057                 org.omg.CORBA.portable.OutputStream $out = _request ("setABCDModules", true);
01058                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01059                 $in = _invoke ($out);
01060                 return;
01061             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01062                 $in = $ex.getInputStream ();
01063                 String _id = $ex.getId ();
01064                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01065                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01066                 else
01067                     throw new org.omg.CORBA.MARSHAL (_id);
01068             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01069                 setABCDModules (bank        );
01070             } finally {
01071                 _releaseReply ($in);
01072             }
01073   } // setABCDModules
01074 
01075   public void sendABCDModule (int mid, Sct_SctApi.BankType bank, int type) throws Sct_SctApi.SctApiException
01076   {
01077             org.omg.CORBA.portable.InputStream $in = null;
01078             try {
01079                 org.omg.CORBA.portable.OutputStream $out = _request ("sendABCDModule", true);
01080                 $out.write_ulong (mid);
01081                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01082                 $out.write_ulong (type);
01083                 $in = _invoke ($out);
01084                 return;
01085             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01086                 $in = $ex.getInputStream ();
01087                 String _id = $ex.getId ();
01088                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01089                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01090                 else
01091                     throw new org.omg.CORBA.MARSHAL (_id);
01092             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01093                 sendABCDModule (mid, bank, type        );
01094             } finally {
01095                 _releaseReply ($in);
01096             }
01097   } // sendABCDModule
01098 
01099   public void sendABCDModules (Sct_SctApi.BankType bank) throws Sct_SctApi.SctApiException
01100   {
01101             org.omg.CORBA.portable.InputStream $in = null;
01102             try {
01103                 org.omg.CORBA.portable.OutputStream $out = _request ("sendABCDModules", true);
01104                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01105                 $in = _invoke ($out);
01106                 return;
01107             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01108                 $in = $ex.getInputStream ();
01109                 String _id = $ex.getId ();
01110                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01111                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01112                 else
01113                     throw new org.omg.CORBA.MARSHAL (_id);
01114             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01115                 sendABCDModules (bank        );
01116             } finally {
01117                 _releaseReply ($in);
01118             }
01119   } // sendABCDModules
01120 
01121   public void modifyABCDMask (int mid, int[] mask)
01122   {
01123             org.omg.CORBA.portable.InputStream $in = null;
01124             try {
01125                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDMask", true);
01126                 $out.write_ulong (mid);
01127                 Sct_SctApi.DataBlockHelper.write ($out, mask);
01128                 $in = _invoke ($out);
01129                 return;
01130             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01131                 $in = $ex.getInputStream ();
01132                 String _id = $ex.getId ();
01133                 throw new org.omg.CORBA.MARSHAL (_id);
01134             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01135                 modifyABCDMask (mid, mask        );
01136             } finally {
01137                 _releaseReply ($in);
01138             }
01139   } // modifyABCDMask
01140 
01141   public void modifyABCDTrims (int mid, short[] trims)
01142   {
01143             org.omg.CORBA.portable.InputStream $in = null;
01144             try {
01145                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDTrims", true);
01146                 $out.write_ulong (mid);
01147                 Sct_SctApi.CharBlockHelper.write ($out, trims);
01148                 $in = _invoke ($out);
01149                 return;
01150             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01151                 $in = $ex.getInputStream ();
01152                 String _id = $ex.getId ();
01153                 throw new org.omg.CORBA.MARSHAL (_id);
01154             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01155                 modifyABCDTrims (mid, trims        );
01156             } finally {
01157                 _releaseReply ($in);
01158             }
01159   } // modifyABCDTrims
01160 
01161   public void modifyABCDRC (int mid, int chip, short index, double p0, double p1, double p2)
01162   {
01163             org.omg.CORBA.portable.InputStream $in = null;
01164             try {
01165                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDRC", true);
01166                 $out.write_ulong (mid);
01167                 $out.write_ulong (chip);
01168                 $out.write_ushort (index);
01169                 $out.write_double (p0);
01170                 $out.write_double (p1);
01171                 $out.write_double (p2);
01172                 $in = _invoke ($out);
01173                 return;
01174             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01175                 $in = $ex.getInputStream ();
01176                 String _id = $ex.getId ();
01177                 throw new org.omg.CORBA.MARSHAL (_id);
01178             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01179                 modifyABCDRC (mid, chip, index, p0, p1, p2        );
01180             } finally {
01181                 _releaseReply ($in);
01182             }
01183   } // modifyABCDRC
01184 
01185 
01186   // must be different prototypes
01187   public void modifyABCDVar (int typ, double var)
01188   {
01189             org.omg.CORBA.portable.InputStream $in = null;
01190             try {
01191                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDVar", true);
01192                 $out.write_ulong (typ);
01193                 $out.write_double (var);
01194                 $in = _invoke ($out);
01195                 return;
01196             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01197                 $in = $ex.getInputStream ();
01198                 String _id = $ex.getId ();
01199                 throw new org.omg.CORBA.MARSHAL (_id);
01200             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01201                 modifyABCDVar (typ, var        );
01202             } finally {
01203                 _releaseReply ($in);
01204             }
01205   } // modifyABCDVar
01206 
01207   public void modifyABCDModuleVar (int mid, int typ, double var)
01208   {
01209             org.omg.CORBA.portable.InputStream $in = null;
01210             try {
01211                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDModuleVar", true);
01212                 $out.write_ulong (mid);
01213                 $out.write_ulong (typ);
01214                 $out.write_double (var);
01215                 $in = _invoke ($out);
01216                 return;
01217             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01218                 $in = $ex.getInputStream ();
01219                 String _id = $ex.getId ();
01220                 throw new org.omg.CORBA.MARSHAL (_id);
01221             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01222                 modifyABCDModuleVar (mid, typ, var        );
01223             } finally {
01224                 _releaseReply ($in);
01225             }
01226   } // modifyABCDModuleVar
01227 
01228   public void modifyABCDChipVar (int mid, int chip, int typ, double var)
01229   {
01230             org.omg.CORBA.portable.InputStream $in = null;
01231             try {
01232                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDChipVar", true);
01233                 $out.write_ulong (mid);
01234                 $out.write_ulong (chip);
01235                 $out.write_ulong (typ);
01236                 $out.write_double (var);
01237                 $in = _invoke ($out);
01238                 return;
01239             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01240                 $in = $ex.getInputStream ();
01241                 String _id = $ex.getId ();
01242                 throw new org.omg.CORBA.MARSHAL (_id);
01243             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01244                 modifyABCDChipVar (mid, chip, typ, var        );
01245             } finally {
01246                 _releaseReply ($in);
01247             }
01248   } // modifyABCDChipVar
01249 
01250   public void modifyABCDVarROD (int typ, double var, Sct_SctApi.BankType bank)
01251   {
01252             org.omg.CORBA.portable.InputStream $in = null;
01253             try {
01254                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDVarROD", true);
01255                 $out.write_ulong (typ);
01256                 $out.write_double (var);
01257                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01258                 $in = _invoke ($out);
01259                 return;
01260             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01261                 $in = $ex.getInputStream ();
01262                 String _id = $ex.getId ();
01263                 throw new org.omg.CORBA.MARSHAL (_id);
01264             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01265                 modifyABCDVarROD (typ, var, bank        );
01266             } finally {
01267                 _releaseReply ($in);
01268             }
01269   } // modifyABCDVarROD
01270 
01271   public void modifyABCDModuleVarROD (int mid, int typ, double var, Sct_SctApi.BankType bank)
01272   {
01273             org.omg.CORBA.portable.InputStream $in = null;
01274             try {
01275                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyABCDModuleVarROD", true);
01276                 $out.write_ulong (mid);
01277                 $out.write_ulong (typ);
01278                 $out.write_double (var);
01279                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01280                 $in = _invoke ($out);
01281                 return;
01282             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01283                 $in = $ex.getInputStream ();
01284                 String _id = $ex.getId ();
01285                 throw new org.omg.CORBA.MARSHAL (_id);
01286             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01287                 modifyABCDModuleVarROD (mid, typ, var, bank        );
01288             } finally {
01289                 _releaseReply ($in);
01290             }
01291   } // modifyABCDModuleVarROD
01292 
01293   public void modifyBOCParam (int partition, int crate, int rod, int channel, int type, int val)
01294   {
01295             org.omg.CORBA.portable.InputStream $in = null;
01296             try {
01297                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyBOCParam", true);
01298                 $out.write_ulong (partition);
01299                 $out.write_ulong (crate);
01300                 $out.write_ulong (rod);
01301                 $out.write_ulong (channel);
01302                 $out.write_ulong (type);
01303                 $out.write_ulong (val);
01304                 $in = _invoke ($out);
01305                 return;
01306             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01307                 $in = $ex.getInputStream ();
01308                 String _id = $ex.getId ();
01309                 throw new org.omg.CORBA.MARSHAL (_id);
01310             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01311                 modifyBOCParam (partition, crate, rod, channel, type, val        );
01312             } finally {
01313                 _releaseReply ($in);
01314             }
01315   } // modifyBOCParam
01316 
01317   public void lasersOff ()
01318   {
01319             org.omg.CORBA.portable.InputStream $in = null;
01320             try {
01321                 org.omg.CORBA.portable.OutputStream $out = _request ("lasersOff", true);
01322                 $in = _invoke ($out);
01323                 return;
01324             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01325                 $in = $ex.getInputStream ();
01326                 String _id = $ex.getId ();
01327                 throw new org.omg.CORBA.MARSHAL (_id);
01328             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01329                 lasersOff (        );
01330             } finally {
01331                 _releaseReply ($in);
01332             }
01333   } // lasersOff
01334 
01335 
01336   /* *************  TIM functs **************/
01337   public void timSetFrequency (int partition, int crate, double trigFreq, double rstFreq)
01338   {
01339             org.omg.CORBA.portable.InputStream $in = null;
01340             try {
01341                 org.omg.CORBA.portable.OutputStream $out = _request ("timSetFrequency", true);
01342                 $out.write_ulong (partition);
01343                 $out.write_ulong (crate);
01344                 $out.write_double (trigFreq);
01345                 $out.write_double (rstFreq);
01346                 $in = _invoke ($out);
01347                 return;
01348             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01349                 $in = $ex.getInputStream ();
01350                 String _id = $ex.getId ();
01351                 throw new org.omg.CORBA.MARSHAL (_id);
01352             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01353                 timSetFrequency (partition, crate, trigFreq, rstFreq        );
01354             } finally {
01355                 _releaseReply ($in);
01356             }
01357   } // timSetFrequency
01358 
01359   public void freeTriggers (int partition, int crate)
01360   {
01361             org.omg.CORBA.portable.InputStream $in = null;
01362             try {
01363                 org.omg.CORBA.portable.OutputStream $out = _request ("freeTriggers", true);
01364                 $out.write_ulong (partition);
01365                 $out.write_ulong (crate);
01366                 $in = _invoke ($out);
01367                 return;
01368             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01369                 $in = $ex.getInputStream ();
01370                 String _id = $ex.getId ();
01371                 throw new org.omg.CORBA.MARSHAL (_id);
01372             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01373                 freeTriggers (partition, crate        );
01374             } finally {
01375                 _releaseReply ($in);
01376             }
01377   } // freeTriggers
01378 
01379   public void stopTriggers (int partition, int crate)
01380   {
01381             org.omg.CORBA.portable.InputStream $in = null;
01382             try {
01383                 org.omg.CORBA.portable.OutputStream $out = _request ("stopTriggers", true);
01384                 $out.write_ulong (partition);
01385                 $out.write_ulong (crate);
01386                 $in = _invoke ($out);
01387                 return;
01388             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01389                 $in = $ex.getInputStream ();
01390                 String _id = $ex.getId ();
01391                 throw new org.omg.CORBA.MARSHAL (_id);
01392             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01393                 stopTriggers (partition, crate        );
01394             } finally {
01395                 _releaseReply ($in);
01396             }
01397   } // stopTriggers
01398 
01399   public void timL1A (int partition, int crate)
01400   {
01401             org.omg.CORBA.portable.InputStream $in = null;
01402             try {
01403                 org.omg.CORBA.portable.OutputStream $out = _request ("timL1A", true);
01404                 $out.write_ulong (partition);
01405                 $out.write_ulong (crate);
01406                 $in = _invoke ($out);
01407                 return;
01408             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01409                 $in = $ex.getInputStream ();
01410                 String _id = $ex.getId ();
01411                 throw new org.omg.CORBA.MARSHAL (_id);
01412             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01413                 timL1A (partition, crate        );
01414             } finally {
01415                 _releaseReply ($in);
01416             }
01417   } // timL1A
01418 
01419   public void timCalL1A (int partition, int crate, short delay)
01420   {
01421             org.omg.CORBA.portable.InputStream $in = null;
01422             try {
01423                 org.omg.CORBA.portable.OutputStream $out = _request ("timCalL1A", true);
01424                 $out.write_ulong (partition);
01425                 $out.write_ulong (crate);
01426                 $out.write_short (delay);
01427                 $in = _invoke ($out);
01428                 return;
01429             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01430                 $in = $ex.getInputStream ();
01431                 String _id = $ex.getId ();
01432                 throw new org.omg.CORBA.MARSHAL (_id);
01433             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01434                 timCalL1A (partition, crate, delay        );
01435             } finally {
01436                 _releaseReply ($in);
01437             }
01438   } // timCalL1A
01439 
01440   public short timReadRegister (int partition, int crate, short value)
01441   {
01442             org.omg.CORBA.portable.InputStream $in = null;
01443             try {
01444                 org.omg.CORBA.portable.OutputStream $out = _request ("timReadRegister", true);
01445                 $out.write_ulong (partition);
01446                 $out.write_ulong (crate);
01447                 $out.write_short (value);
01448                 $in = _invoke ($out);
01449                 short $result = $in.read_short ();
01450                 return $result;
01451             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01452                 $in = $ex.getInputStream ();
01453                 String _id = $ex.getId ();
01454                 throw new org.omg.CORBA.MARSHAL (_id);
01455             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01456                 return timReadRegister (partition, crate, value        );
01457             } finally {
01458                 _releaseReply ($in);
01459             }
01460   } // timReadRegister
01461 
01462   public void timWriteRegister (int partition, int crate, short reg, short value)
01463   {
01464             org.omg.CORBA.portable.InputStream $in = null;
01465             try {
01466                 org.omg.CORBA.portable.OutputStream $out = _request ("timWriteRegister", true);
01467                 $out.write_ulong (partition);
01468                 $out.write_ulong (crate);
01469                 $out.write_short (reg);
01470                 $out.write_short (value);
01471                 $in = _invoke ($out);
01472                 return;
01473             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01474                 $in = $ex.getInputStream ();
01475                 String _id = $ex.getId ();
01476                 throw new org.omg.CORBA.MARSHAL (_id);
01477             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01478                 timWriteRegister (partition, crate, reg, value        );
01479             } finally {
01480                 _releaseReply ($in);
01481             }
01482   } // timWriteRegister
01483 
01484   public void sendTimTrigger (int partition, int crate, Sct_SctApi.Trigger trig)
01485   {
01486             org.omg.CORBA.portable.InputStream $in = null;
01487             try {
01488                 org.omg.CORBA.portable.OutputStream $out = _request ("sendTimTrigger", true);
01489                 $out.write_ulong (partition);
01490                 $out.write_ulong (crate);
01491                 Sct_SctApi.TriggerHelper.write ($out, trig);
01492                 $in = _invoke ($out);
01493                 return;
01494             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01495                 $in = $ex.getInputStream ();
01496                 String _id = $ex.getId ();
01497                 throw new org.omg.CORBA.MARSHAL (_id);
01498             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01499                 sendTimTrigger (partition, crate, trig        );
01500             } finally {
01501                 _releaseReply ($in);
01502             }
01503   } // sendTimTrigger
01504 
01505   public void sendTrigger (int partition, int crate, int rod, Sct_SctApi.Trigger trig)
01506   {
01507             org.omg.CORBA.portable.InputStream $in = null;
01508             try {
01509                 org.omg.CORBA.portable.OutputStream $out = _request ("sendTrigger", true);
01510                 $out.write_ulong (partition);
01511                 $out.write_ulong (crate);
01512                 $out.write_ulong (rod);
01513                 Sct_SctApi.TriggerHelper.write ($out, trig);
01514                 $in = _invoke ($out);
01515                 return;
01516             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01517                 $in = $ex.getInputStream ();
01518                 String _id = $ex.getId ();
01519                 throw new org.omg.CORBA.MARSHAL (_id);
01520             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01521                 sendTrigger (partition, crate, rod, trig        );
01522             } finally {
01523                 _releaseReply ($in);
01524             }
01525   } // sendTrigger
01526 
01527 
01528   // Scans
01529   public void doScan (Sct_SctApi.Scan thisScan) throws Sct_SctApi.SctApiException
01530   {
01531             org.omg.CORBA.portable.InputStream $in = null;
01532             try {
01533                 org.omg.CORBA.portable.OutputStream $out = _request ("doScan", true);
01534                 Sct_SctApi.ScanHelper.write ($out, thisScan);
01535                 $in = _invoke ($out);
01536                 return;
01537             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01538                 $in = $ex.getInputStream ();
01539                 String _id = $ex.getId ();
01540                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01541                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01542                 else
01543                     throw new org.omg.CORBA.MARSHAL (_id);
01544             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01545                 doScan (thisScan        );
01546             } finally {
01547                 _releaseReply ($in);
01548             }
01549   } // doScan
01550 
01551   public void doRawScan (Sct_SctApi.Scan thisScan, int delay, int width, boolean configure, boolean clockByTwo) throws Sct_SctApi.SctApiException
01552   {
01553             org.omg.CORBA.portable.InputStream $in = null;
01554             try {
01555                 org.omg.CORBA.portable.OutputStream $out = _request ("doRawScan", true);
01556                 Sct_SctApi.ScanHelper.write ($out, thisScan);
01557                 $out.write_long (delay);
01558                 $out.write_long (width);
01559                 $out.write_boolean (configure);
01560                 $out.write_boolean (clockByTwo);
01561                 $in = _invoke ($out);
01562                 return;
01563             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01564                 $in = $ex.getInputStream ();
01565                 String _id = $ex.getId ();
01566                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01567                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01568                 else
01569                     throw new org.omg.CORBA.MARSHAL (_id);
01570             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01571                 doRawScan (thisScan, delay, width, configure, clockByTwo        );
01572             } finally {
01573                 _releaseReply ($in);
01574             }
01575   } // doRawScan
01576 
01577   public void printBOCSetup (int partition, int crate, int rod)
01578   {
01579             org.omg.CORBA.portable.InputStream $in = null;
01580             try {
01581                 org.omg.CORBA.portable.OutputStream $out = _request ("printBOCSetup", true);
01582                 $out.write_ulong (partition);
01583                 $out.write_ulong (crate);
01584                 $out.write_ulong (rod);
01585                 $in = _invoke ($out);
01586                 return;
01587             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01588                 $in = $ex.getInputStream ();
01589                 String _id = $ex.getId ();
01590                 throw new org.omg.CORBA.MARSHAL (_id);
01591             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01592                 printBOCSetup (partition, crate, rod        );
01593             } finally {
01594                 _releaseReply ($in);
01595             }
01596   } // printBOCSetup
01597 
01598   public sctConf.BOCChannelConfig[] currentBOCSetup (int partition, int crate, int rod)
01599   {
01600             org.omg.CORBA.portable.InputStream $in = null;
01601             try {
01602                 org.omg.CORBA.portable.OutputStream $out = _request ("currentBOCSetup", true);
01603                 $out.write_ulong (partition);
01604                 $out.write_ulong (crate);
01605                 $out.write_ulong (rod);
01606                 $in = _invoke ($out);
01607                 sctConf.BOCChannelConfig $result[] = Sct_SctApi.BOCChannelListHelper.read ($in);
01608                 return $result;
01609             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01610                 $in = $ex.getInputStream ();
01611                 String _id = $ex.getId ();
01612                 throw new org.omg.CORBA.MARSHAL (_id);
01613             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01614                 return currentBOCSetup (partition, crate, rod        );
01615             } finally {
01616                 _releaseReply ($in);
01617             }
01618   } // currentBOCSetup
01619 
01620   public sctConf.BOCGlobalConfig currentBOCRegisters (int partition, int crate, int rod)
01621   {
01622             org.omg.CORBA.portable.InputStream $in = null;
01623             try {
01624                 org.omg.CORBA.portable.OutputStream $out = _request ("currentBOCRegisters", true);
01625                 $out.write_ulong (partition);
01626                 $out.write_ulong (crate);
01627                 $out.write_ulong (rod);
01628                 $in = _invoke ($out);
01629                 sctConf.BOCGlobalConfig $result = sctConf.BOCGlobalConfigHelper.read ($in);
01630                 return $result;
01631             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01632                 $in = $ex.getInputStream ();
01633                 String _id = $ex.getId ();
01634                 throw new org.omg.CORBA.MARSHAL (_id);
01635             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01636                 return currentBOCRegisters (partition, crate, rod        );
01637             } finally {
01638                 _releaseReply ($in);
01639             }
01640   } // currentBOCRegisters
01641 
01642   public void printABCDModule (int mid)
01643   {
01644             org.omg.CORBA.portable.InputStream $in = null;
01645             try {
01646                 org.omg.CORBA.portable.OutputStream $out = _request ("printABCDModule", true);
01647                 $out.write_ulong (mid);
01648                 $in = _invoke ($out);
01649                 return;
01650             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01651                 $in = $ex.getInputStream ();
01652                 String _id = $ex.getId ();
01653                 throw new org.omg.CORBA.MARSHAL (_id);
01654             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01655                 printABCDModule (mid        );
01656             } finally {
01657                 _releaseReply ($in);
01658             }
01659   } // printABCDModule
01660 
01661   public void printABCDRodModule (int mid, Sct_SctApi.BankType bank)
01662   {
01663             org.omg.CORBA.portable.InputStream $in = null;
01664             try {
01665                 org.omg.CORBA.portable.OutputStream $out = _request ("printABCDRodModule", true);
01666                 $out.write_ulong (mid);
01667                 Sct_SctApi.BankTypeHelper.write ($out, bank);
01668                 $in = _invoke ($out);
01669                 return;
01670             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01671                 $in = $ex.getInputStream ();
01672                 String _id = $ex.getId ();
01673                 throw new org.omg.CORBA.MARSHAL (_id);
01674             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01675                 printABCDRodModule (mid, bank        );
01676             } finally {
01677                 _releaseReply ($in);
01678             }
01679   } // printABCDRodModule
01680 
01681   public void decodeEvent (int partition, int crate, int rod, short sl, short index, boolean extFlag, boolean errorType)
01682   {
01683             org.omg.CORBA.portable.InputStream $in = null;
01684             try {
01685                 org.omg.CORBA.portable.OutputStream $out = _request ("decodeEvent", true);
01686                 $out.write_ulong (partition);
01687                 $out.write_ulong (crate);
01688                 $out.write_ulong (rod);
01689                 $out.write_short (sl);
01690                 $out.write_short (index);
01691                 $out.write_boolean (extFlag);
01692                 $out.write_boolean (errorType);
01693                 $in = _invoke ($out);
01694                 return;
01695             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01696                 $in = $ex.getInputStream ();
01697                 String _id = $ex.getId ();
01698                 throw new org.omg.CORBA.MARSHAL (_id);
01699             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01700                 decodeEvent (partition, crate, rod, sl, index, extFlag, errorType        );
01701             } finally {
01702                 _releaseReply ($in);
01703             }
01704   } // decodeEvent
01705 
01706   public void rawData (int partition, int crate, int rod, int delay, int units, boolean setMask)
01707   {
01708             org.omg.CORBA.portable.InputStream $in = null;
01709             try {
01710                 org.omg.CORBA.portable.OutputStream $out = _request ("rawData", true);
01711                 $out.write_ulong (partition);
01712                 $out.write_ulong (crate);
01713                 $out.write_ulong (rod);
01714                 $out.write_long (delay);
01715                 $out.write_long (units);
01716                 $out.write_boolean (setMask);
01717                 $in = _invoke ($out);
01718                 return;
01719             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01720                 $in = $ex.getInputStream ();
01721                 String _id = $ex.getId ();
01722                 throw new org.omg.CORBA.MARSHAL (_id);
01723             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01724                 rawData (partition, crate, rod, delay, units, setMask        );
01725             } finally {
01726                 _releaseReply ($in);
01727             }
01728   } // rawData
01729 
01730   public void rawDataWithTrigger (int partition, int crate, int rod, int delay, int units, boolean setMask, Sct_SctApi.Trigger trig)
01731   {
01732             org.omg.CORBA.portable.InputStream $in = null;
01733             try {
01734                 org.omg.CORBA.portable.OutputStream $out = _request ("rawDataWithTrigger", true);
01735                 $out.write_ulong (partition);
01736                 $out.write_ulong (crate);
01737                 $out.write_ulong (rod);
01738                 $out.write_long (delay);
01739                 $out.write_long (units);
01740                 $out.write_boolean (setMask);
01741                 Sct_SctApi.TriggerHelper.write ($out, trig);
01742                 $in = _invoke ($out);
01743                 return;
01744             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01745                 $in = $ex.getInputStream ();
01746                 String _id = $ex.getId ();
01747                 throw new org.omg.CORBA.MARSHAL (_id);
01748             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01749                 rawDataWithTrigger (partition, crate, rod, delay, units, setMask, trig        );
01750             } finally {
01751                 _releaseReply ($in);
01752             }
01753   } // rawDataWithTrigger
01754 
01755   public void sendL1A (int partition, int crate, int rod)
01756   {
01757             org.omg.CORBA.portable.InputStream $in = null;
01758             try {
01759                 org.omg.CORBA.portable.OutputStream $out = _request ("sendL1A", true);
01760                 $out.write_ulong (partition);
01761                 $out.write_ulong (crate);
01762                 $out.write_ulong (rod);
01763                 $in = _invoke ($out);
01764                 return;
01765             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01766                 $in = $ex.getInputStream ();
01767                 String _id = $ex.getId ();
01768                 throw new org.omg.CORBA.MARSHAL (_id);
01769             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01770                 sendL1A (partition, crate, rod        );
01771             } finally {
01772                 _releaseReply ($in);
01773             }
01774   } // sendL1A
01775 
01776   public short[] probe (int partition, int crate, int rod)
01777   {
01778             org.omg.CORBA.portable.InputStream $in = null;
01779             try {
01780                 org.omg.CORBA.portable.OutputStream $out = _request ("probe", true);
01781                 $out.write_ulong (partition);
01782                 $out.write_ulong (crate);
01783                 $out.write_ulong (rod);
01784                 $in = _invoke ($out);
01785                 short $result[] = Sct_SctApi.CharBlockHelper.read ($in);
01786                 return $result;
01787             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01788                 $in = $ex.getInputStream ();
01789                 String _id = $ex.getId ();
01790                 throw new org.omg.CORBA.MARSHAL (_id);
01791             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01792                 return probe (partition, crate, rod        );
01793             } finally {
01794                 _releaseReply ($in);
01795             }
01796   } // probe
01797 
01798   public short[] probeHarness (int partition, int crate, int rod, int harness)
01799   {
01800             org.omg.CORBA.portable.InputStream $in = null;
01801             try {
01802                 org.omg.CORBA.portable.OutputStream $out = _request ("probeHarness", true);
01803                 $out.write_ulong (partition);
01804                 $out.write_ulong (crate);
01805                 $out.write_ulong (rod);
01806                 $out.write_ulong (harness);
01807                 $in = _invoke ($out);
01808                 short $result[] = Sct_SctApi.CharBlockHelper.read ($in);
01809                 return $result;
01810             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01811                 $in = $ex.getInputStream ();
01812                 String _id = $ex.getId ();
01813                 throw new org.omg.CORBA.MARSHAL (_id);
01814             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01815                 return probeHarness (partition, crate, rod, harness        );
01816             } finally {
01817                 _releaseReply ($in);
01818             }
01819   } // probeHarness
01820 
01821   public short[] probeWithTrigger (int partition, int crate, int rod, Sct_SctApi.Trigger trig)
01822   {
01823             org.omg.CORBA.portable.InputStream $in = null;
01824             try {
01825                 org.omg.CORBA.portable.OutputStream $out = _request ("probeWithTrigger", true);
01826                 $out.write_ulong (partition);
01827                 $out.write_ulong (crate);
01828                 $out.write_ulong (rod);
01829                 Sct_SctApi.TriggerHelper.write ($out, trig);
01830                 $in = _invoke ($out);
01831                 short $result[] = Sct_SctApi.CharBlockHelper.read ($in);
01832                 return $result;
01833             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01834                 $in = $ex.getInputStream ();
01835                 String _id = $ex.getId ();
01836                 throw new org.omg.CORBA.MARSHAL (_id);
01837             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01838                 return probeWithTrigger (partition, crate, rod, trig        );
01839             } finally {
01840                 _releaseReply ($in);
01841             }
01842   } // probeWithTrigger
01843 
01844   public short[] probeHarnessWithTrigger (int partition, int crate, int rod, Sct_SctApi.Trigger trig, int harness)
01845   {
01846             org.omg.CORBA.portable.InputStream $in = null;
01847             try {
01848                 org.omg.CORBA.portable.OutputStream $out = _request ("probeHarnessWithTrigger", true);
01849                 $out.write_ulong (partition);
01850                 $out.write_ulong (crate);
01851                 $out.write_ulong (rod);
01852                 Sct_SctApi.TriggerHelper.write ($out, trig);
01853                 $out.write_ulong (harness);
01854                 $in = _invoke ($out);
01855                 short $result[] = Sct_SctApi.CharBlockHelper.read ($in);
01856                 return $result;
01857             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01858                 $in = $ex.getInputStream ();
01859                 String _id = $ex.getId ();
01860                 throw new org.omg.CORBA.MARSHAL (_id);
01861             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01862                 return probeHarnessWithTrigger (partition, crate, rod, trig, harness        );
01863             } finally {
01864                 _releaseReply ($in);
01865             }
01866   } // probeHarnessWithTrigger
01867 
01868   public short[][] probeScanHarnessWithTrigger (int partition, int crate, int rod, Sct_SctApi.Scan trig, int harness)
01869   {
01870             org.omg.CORBA.portable.InputStream $in = null;
01871             try {
01872                 org.omg.CORBA.portable.OutputStream $out = _request ("probeScanHarnessWithTrigger", true);
01873                 $out.write_ulong (partition);
01874                 $out.write_ulong (crate);
01875                 $out.write_ulong (rod);
01876                 Sct_SctApi.ScanHelper.write ($out, trig);
01877                 $out.write_ulong (harness);
01878                 $in = _invoke ($out);
01879                 short $result[][] = Sct_SctApi.CharMatrixHelper.read ($in);
01880                 return $result;
01881             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01882                 $in = $ex.getInputStream ();
01883                 String _id = $ex.getId ();
01884                 throw new org.omg.CORBA.MARSHAL (_id);
01885             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01886                 return probeScanHarnessWithTrigger (partition, crate, rod, trig, harness        );
01887             } finally {
01888                 _releaseReply ($in);
01889             }
01890   } // probeScanHarnessWithTrigger
01891 
01892   public boolean checkAllModulesProbe (String chars) throws Sct_SctApi.SctApiException
01893   {
01894             org.omg.CORBA.portable.InputStream $in = null;
01895             try {
01896                 org.omg.CORBA.portable.OutputStream $out = _request ("checkAllModulesProbe", true);
01897                 $out.write_string (chars);
01898                 $in = _invoke ($out);
01899                 boolean $result = $in.read_boolean ();
01900                 return $result;
01901             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01902                 $in = $ex.getInputStream ();
01903                 String _id = $ex.getId ();
01904                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01905                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01906                 else
01907                     throw new org.omg.CORBA.MARSHAL (_id);
01908             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01909                 return checkAllModulesProbe (chars        );
01910             } finally {
01911                 _releaseReply ($in);
01912             }
01913   } // checkAllModulesProbe
01914 
01915   public Sct_SctApi.AutoConfigResult[] autoConfigureScan () throws Sct_SctApi.SctApiException
01916   {
01917             org.omg.CORBA.portable.InputStream $in = null;
01918             try {
01919                 org.omg.CORBA.portable.OutputStream $out = _request ("autoConfigureScan", true);
01920                 $in = _invoke ($out);
01921                 Sct_SctApi.AutoConfigResult $result[] = Sct_SctApi.AutoResultListHelper.read ($in);
01922                 return $result;
01923             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01924                 $in = $ex.getInputStream ();
01925                 String _id = $ex.getId ();
01926                 if (_id.equals ("IDL:Sct_SctApi/SctApiException:1.0"))
01927                     throw Sct_SctApi.SctApiExceptionHelper.read ($in);
01928                 else
01929                     throw new org.omg.CORBA.MARSHAL (_id);
01930             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01931                 return autoConfigureScan (        );
01932             } finally {
01933                 _releaseReply ($in);
01934             }
01935   } // autoConfigureScan
01936 
01937   public int getRodSlot (int partition, int crate, int rod)
01938   {
01939             org.omg.CORBA.portable.InputStream $in = null;
01940             try {
01941                 org.omg.CORBA.portable.OutputStream $out = _request ("getRodSlot", true);
01942                 $out.write_ulong (partition);
01943                 $out.write_ulong (crate);
01944                 $out.write_ulong (rod);
01945                 $in = _invoke ($out);
01946                 int $result = $in.read_ulong ();
01947                 return $result;
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                 return getRodSlot (partition, crate, rod        );
01954             } finally {
01955                 _releaseReply ($in);
01956             }
01957   } // getRodSlot
01958 
01959   public void testLinkOutSelect (int partition, int crate, int rod, int link)
01960   {
01961             org.omg.CORBA.portable.InputStream $in = null;
01962             try {
01963                 org.omg.CORBA.portable.OutputStream $out = _request ("testLinkOutSelect", true);
01964                 $out.write_ulong (partition);
01965                 $out.write_ulong (crate);
01966                 $out.write_ulong (rod);
01967                 $out.write_ulong (link);
01968                 $in = _invoke ($out);
01969                 return;
01970             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01971                 $in = $ex.getInputStream ();
01972                 String _id = $ex.getId ();
01973                 throw new org.omg.CORBA.MARSHAL (_id);
01974             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01975                 testLinkOutSelect (partition, crate, rod, link        );
01976             } finally {
01977                 _releaseReply ($in);
01978             }
01979   } // testLinkOutSelect
01980 
01981   public int testLinkOutRetrieve (int partition, int crate, int rod)
01982   {
01983             org.omg.CORBA.portable.InputStream $in = null;
01984             try {
01985                 org.omg.CORBA.portable.OutputStream $out = _request ("testLinkOutRetrieve", true);
01986                 $out.write_ulong (partition);
01987                 $out.write_ulong (crate);
01988                 $out.write_ulong (rod);
01989                 $in = _invoke ($out);
01990                 int $result = $in.read_ulong ();
01991                 return $result;
01992             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01993                 $in = $ex.getInputStream ();
01994                 String _id = $ex.getId ();
01995                 throw new org.omg.CORBA.MARSHAL (_id);
01996             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01997                 return testLinkOutRetrieve (partition, crate, rod        );
01998             } finally {
01999                 _releaseReply ($in);
02000             }
02001   } // testLinkOutRetrieve
02002 
02003 
02004   // DCS stuff
02005   public void requestHardReset (int mid)
02006   {
02007             org.omg.CORBA.portable.InputStream $in = null;
02008             try {
02009                 org.omg.CORBA.portable.OutputStream $out = _request ("requestHardReset", true);
02010                 $out.write_ulong (mid);
02011                 $in = _invoke ($out);
02012                 return;
02013             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02014                 $in = $ex.getInputStream ();
02015                 String _id = $ex.getId ();
02016                 throw new org.omg.CORBA.MARSHAL (_id);
02017             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02018                 requestHardReset (mid        );
02019             } finally {
02020                 _releaseReply ($in);
02021             }
02022   } // requestHardReset
02023 
02024   public void requestIVCurve (int mid, float start, float stop, float step, short delay, float currentLim)
02025   {
02026             org.omg.CORBA.portable.InputStream $in = null;
02027             try {
02028                 org.omg.CORBA.portable.OutputStream $out = _request ("requestIVCurve", true);
02029                 $out.write_ulong (mid);
02030                 $out.write_float (start);
02031                 $out.write_float (stop);
02032                 $out.write_float (step);
02033                 $out.write_ushort (delay);
02034                 $out.write_float (currentLim);
02035                 $in = _invoke ($out);
02036                 return;
02037             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02038                 $in = $ex.getInputStream ();
02039                 String _id = $ex.getId ();
02040                 throw new org.omg.CORBA.MARSHAL (_id);
02041             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02042                 requestIVCurve (mid, start, stop, step, delay, currentLim        );
02043             } finally {
02044                 _releaseReply ($in);
02045             }
02046   } // requestIVCurve
02047 
02048   public void setSelect (int mid, boolean value)
02049   {
02050             org.omg.CORBA.portable.InputStream $in = null;
02051             try {
02052                 org.omg.CORBA.portable.OutputStream $out = _request ("setSelect", true);
02053                 $out.write_ulong (mid);
02054                 $out.write_boolean (value);
02055                 $in = _invoke ($out);
02056                 return;
02057             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02058                 $in = $ex.getInputStream ();
02059                 String _id = $ex.getId ();
02060                 throw new org.omg.CORBA.MARSHAL (_id);
02061             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02062                 setSelect (mid, value        );
02063             } finally {
02064                 _releaseReply ($in);
02065             }
02066   } // setSelect
02067 
02068   public void setSelectAllInCrate (int crate, boolean value)
02069   {
02070             org.omg.CORBA.portable.InputStream $in = null;
02071             try {
02072                 org.omg.CORBA.portable.OutputStream $out = _request ("setSelectAllInCrate", true);
02073                 $out.write_long (crate);
02074                 $out.write_boolean (value);
02075                 $in = _invoke ($out);
02076                 return;
02077             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02078                 $in = $ex.getInputStream ();
02079                 String _id = $ex.getId ();
02080                 throw new org.omg.CORBA.MARSHAL (_id);
02081             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02082                 setSelectAllInCrate (crate, value        );
02083             } finally {
02084                 _releaseReply ($in);
02085             }
02086   } // setSelectAllInCrate
02087 
02088   public void changeRunState (int state)
02089   {
02090             org.omg.CORBA.portable.InputStream $in = null;
02091             try {
02092                 org.omg.CORBA.portable.OutputStream $out = _request ("changeRunState", true);
02093                 $out.write_long (state);
02094                 $in = _invoke ($out);
02095                 return;
02096             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02097                 $in = $ex.getInputStream ();
02098                 String _id = $ex.getId ();
02099                 throw new org.omg.CORBA.MARSHAL (_id);
02100             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02101                 changeRunState (state        );
02102             } finally {
02103                 _releaseReply ($in);
02104             }
02105   } // changeRunState
02106 
02107 
02108   //                                 out long dpeValue);          // Put timeout in here?
02109   public void ddcSetSingleTimeout (short timeout)
02110   {
02111             org.omg.CORBA.portable.InputStream $in = null;
02112             try {
02113                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcSetSingleTimeout", true);
02114                 $out.write_short (timeout);
02115                 $in = _invoke ($out);
02116                 return;
02117             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02118                 $in = $ex.getInputStream ();
02119                 String _id = $ex.getId ();
02120                 throw new org.omg.CORBA.MARSHAL (_id);
02121             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02122                 ddcSetSingleTimeout (timeout        );
02123             } finally {
02124                 _releaseReply ($in);
02125             }
02126   } // ddcSetSingleTimeout
02127 
02128   public short ddcGetSingleTimeout ()
02129   {
02130             org.omg.CORBA.portable.InputStream $in = null;
02131             try {
02132                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetSingleTimeout", true);
02133                 $in = _invoke ($out);
02134                 short $result = $in.read_short ();
02135                 return $result;
02136             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02137                 $in = $ex.getInputStream ();
02138                 String _id = $ex.getId ();
02139                 throw new org.omg.CORBA.MARSHAL (_id);
02140             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02141                 return ddcGetSingleTimeout (        );
02142             } finally {
02143                 _releaseReply ($in);
02144             }
02145   } // ddcGetSingleTimeout
02146 
02147   public void ddcSetMultipleTimeout (short timeout)
02148   {
02149             org.omg.CORBA.portable.InputStream $in = null;
02150             try {
02151                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcSetMultipleTimeout", true);
02152                 $out.write_short (timeout);
02153                 $in = _invoke ($out);
02154                 return;
02155             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02156                 $in = $ex.getInputStream ();
02157                 String _id = $ex.getId ();
02158                 throw new org.omg.CORBA.MARSHAL (_id);
02159             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02160                 ddcSetMultipleTimeout (timeout        );
02161             } finally {
02162                 _releaseReply ($in);
02163             }
02164   } // ddcSetMultipleTimeout
02165 
02166   public short ddcGetMultipleTimeout ()
02167   {
02168             org.omg.CORBA.portable.InputStream $in = null;
02169             try {
02170                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetMultipleTimeout", true);
02171                 $in = _invoke ($out);
02172                 short $result = $in.read_short ();
02173                 return $result;
02174             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02175                 $in = $ex.getInputStream ();
02176                 String _id = $ex.getId ();
02177                 throw new org.omg.CORBA.MARSHAL (_id);
02178             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02179                 return ddcGetMultipleTimeout (        );
02180             } finally {
02181                 _releaseReply ($in);
02182             }
02183   } // ddcGetMultipleTimeout
02184 
02185   public void ddcChangeState (int crate, int channel, short state)
02186   {
02187             org.omg.CORBA.portable.InputStream $in = null;
02188             try {
02189                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcChangeState", true);
02190                 $out.write_long (crate);
02191                 $out.write_long (channel);
02192                 $out.write_short (state);
02193                 $in = _invoke ($out);
02194                 return;
02195             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02196                 $in = $ex.getInputStream ();
02197                 String _id = $ex.getId ();
02198                 throw new org.omg.CORBA.MARSHAL (_id);
02199             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02200                 ddcChangeState (crate, channel, state        );
02201             } finally {
02202                 _releaseReply ($in);
02203             }
02204   } // ddcChangeState
02205 
02206 
02207   // MultipleTimeout
02208   public void ddcChangeStateAll (int crate, short state)
02209   {
02210             org.omg.CORBA.portable.InputStream $in = null;
02211             try {
02212                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcChangeStateAll", true);
02213                 $out.write_long (crate);
02214                 $out.write_short (state);
02215                 $in = _invoke ($out);
02216                 return;
02217             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02218                 $in = $ex.getInputStream ();
02219                 String _id = $ex.getId ();
02220                 throw new org.omg.CORBA.MARSHAL (_id);
02221             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02222                 ddcChangeStateAll (crate, state        );
02223             } finally {
02224                 _releaseReply ($in);
02225             }
02226   } // ddcChangeStateAll
02227 
02228 
02229   // MultipleTimeout
02230   public void ddcLoadConfiguration (int crate, short state)
02231   {
02232             org.omg.CORBA.portable.InputStream $in = null;
02233             try {
02234                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcLoadConfiguration", true);
02235                 $out.write_long (crate);
02236                 $out.write_short (state);
02237                 $in = _invoke ($out);
02238                 return;
02239             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02240                 $in = $ex.getInputStream ();
02241                 String _id = $ex.getId ();
02242                 throw new org.omg.CORBA.MARSHAL (_id);
02243             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02244                 ddcLoadConfiguration (crate, state        );
02245             } finally {
02246                 _releaseReply ($in);
02247             }
02248   } // ddcLoadConfiguration
02249 
02250 
02251   // MultipleTimeout
02252   public void ddcHardReset (int crate, int channel)
02253   {
02254             org.omg.CORBA.portable.InputStream $in = null;
02255             try {
02256                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcHardReset", true);
02257                 $out.write_long (crate);
02258                 $out.write_long (channel);
02259                 $in = _invoke ($out);
02260                 return;
02261             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02262                 $in = $ex.getInputStream ();
02263                 String _id = $ex.getId ();
02264                 throw new org.omg.CORBA.MARSHAL (_id);
02265             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02266                 ddcHardReset (crate, channel        );
02267             } finally {
02268                 _releaseReply ($in);
02269             }
02270   } // ddcHardReset
02271 
02272 
02273   // SingleTimeout
02274   public void ddcHardResetAll (int crate)
02275   {
02276             org.omg.CORBA.portable.InputStream $in = null;
02277             try {
02278                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcHardResetAll", true);
02279                 $out.write_long (crate);
02280                 $in = _invoke ($out);
02281                 return;
02282             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02283                 $in = $ex.getInputStream ();
02284                 String _id = $ex.getId ();
02285                 throw new org.omg.CORBA.MARSHAL (_id);
02286             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02287                 ddcHardResetAll (crate        );
02288             } finally {
02289                 _releaseReply ($in);
02290             }
02291   } // ddcHardResetAll
02292 
02293 
02294   // MultipleTimeout
02295   public int ddcGetChannelParameterInt (int crate, int channel, String name)
02296   {
02297             org.omg.CORBA.portable.InputStream $in = null;
02298             try {
02299                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetChannelParameterInt", true);
02300                 $out.write_long (crate);
02301                 $out.write_long (channel);
02302                 $out.write_string (name);
02303                 $in = _invoke ($out);
02304                 int $result = $in.read_ulong ();
02305                 return $result;
02306             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02307                 $in = $ex.getInputStream ();
02308                 String _id = $ex.getId ();
02309                 throw new org.omg.CORBA.MARSHAL (_id);
02310             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02311                 return ddcGetChannelParameterInt (crate, channel, name        );
02312             } finally {
02313                 _releaseReply ($in);
02314             }
02315   } // ddcGetChannelParameterInt
02316 
02317 
02318   // SingleTimeout
02319   public float ddcGetChannelParameterFloat (int crate, int channel, String name)
02320   {
02321             org.omg.CORBA.portable.InputStream $in = null;
02322             try {
02323                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetChannelParameterFloat", true);
02324                 $out.write_long (crate);
02325                 $out.write_long (channel);
02326                 $out.write_string (name);
02327                 $in = _invoke ($out);
02328                 float $result = $in.read_float ();
02329                 return $result;
02330             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02331                 $in = $ex.getInputStream ();
02332                 String _id = $ex.getId ();
02333                 throw new org.omg.CORBA.MARSHAL (_id);
02334             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02335                 return ddcGetChannelParameterFloat (crate, channel, name        );
02336             } finally {
02337                 _releaseReply ($in);
02338             }
02339   } // ddcGetChannelParameterFloat
02340 
02341 
02342   // SingleTimeout
02343   public String ddcGetChannelParameterString (int crate, int channel, String name)
02344   {
02345             org.omg.CORBA.portable.InputStream $in = null;
02346             try {
02347                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetChannelParameterString", true);
02348                 $out.write_long (crate);
02349                 $out.write_long (channel);
02350                 $out.write_string (name);
02351                 $in = _invoke ($out);
02352                 String $result = $in.read_string ();
02353                 return $result;
02354             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02355                 $in = $ex.getInputStream ();
02356                 String _id = $ex.getId ();
02357                 throw new org.omg.CORBA.MARSHAL (_id);
02358             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02359                 return ddcGetChannelParameterString (crate, channel, name        );
02360             } finally {
02361                 _releaseReply ($in);
02362             }
02363   } // ddcGetChannelParameterString
02364 
02365 
02366   // SingleTimeout
02367   public int ddcGetCardParameterInt (int crate, int card, String name)
02368   {
02369             org.omg.CORBA.portable.InputStream $in = null;
02370             try {
02371                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetCardParameterInt", true);
02372                 $out.write_long (crate);
02373                 $out.write_long (card);
02374                 $out.write_string (name);
02375                 $in = _invoke ($out);
02376                 int $result = $in.read_ulong ();
02377                 return $result;
02378             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02379                 $in = $ex.getInputStream ();
02380                 String _id = $ex.getId ();
02381                 throw new org.omg.CORBA.MARSHAL (_id);
02382             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02383                 return ddcGetCardParameterInt (crate, card, name        );
02384             } finally {
02385                 _releaseReply ($in);
02386             }
02387   } // ddcGetCardParameterInt
02388 
02389 
02390   // SingleTimeout
02391   public float ddcGetCardParameterFloat (int crate, int card, String name)
02392   {
02393             org.omg.CORBA.portable.InputStream $in = null;
02394             try {
02395                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetCardParameterFloat", true);
02396                 $out.write_long (crate);
02397                 $out.write_long (card);
02398                 $out.write_string (name);
02399                 $in = _invoke ($out);
02400                 float $result = $in.read_float ();
02401                 return $result;
02402             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02403                 $in = $ex.getInputStream ();
02404                 String _id = $ex.getId ();
02405                 throw new org.omg.CORBA.MARSHAL (_id);
02406             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02407                 return ddcGetCardParameterFloat (crate, card, name        );
02408             } finally {
02409                 _releaseReply ($in);
02410             }
02411   } // ddcGetCardParameterFloat
02412 
02413 
02414   // SingleTimeout
02415   public String ddcGetCardParameterString (int crate, int card, String name)
02416   {
02417             org.omg.CORBA.portable.InputStream $in = null;
02418             try {
02419                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetCardParameterString", true);
02420                 $out.write_long (crate);
02421                 $out.write_long (card);
02422                 $out.write_string (name);
02423                 $in = _invoke ($out);
02424                 String $result = $in.read_string ();
02425                 return $result;
02426             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02427                 $in = $ex.getInputStream ();
02428                 String _id = $ex.getId ();
02429                 throw new org.omg.CORBA.MARSHAL (_id);
02430             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02431                 return ddcGetCardParameterString (crate, card, name        );
02432             } finally {
02433                 _releaseReply ($in);
02434             }
02435   } // ddcGetCardParameterString
02436 
02437 
02438   // SingleTimeout
02439   public int ddcGetCrateParameterInt (int crate, String name)
02440   {
02441             org.omg.CORBA.portable.InputStream $in = null;
02442             try {
02443                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetCrateParameterInt", true);
02444                 $out.write_long (crate);
02445                 $out.write_string (name);
02446                 $in = _invoke ($out);
02447                 int $result = $in.read_ulong ();
02448                 return $result;
02449             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02450                 $in = $ex.getInputStream ();
02451                 String _id = $ex.getId ();
02452                 throw new org.omg.CORBA.MARSHAL (_id);
02453             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02454                 return ddcGetCrateParameterInt (crate, name        );
02455             } finally {
02456                 _releaseReply ($in);
02457             }
02458   } // ddcGetCrateParameterInt
02459 
02460 
02461   // SingleTimeout
02462   public float ddcGetCrateParameterFloat (int crate, String name)
02463   {
02464             org.omg.CORBA.portable.InputStream $in = null;
02465             try {
02466                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetCrateParameterFloat", true);
02467                 $out.write_long (crate);
02468                 $out.write_string (name);
02469                 $in = _invoke ($out);
02470                 float $result = $in.read_float ();
02471                 return $result;
02472             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02473                 $in = $ex.getInputStream ();
02474                 String _id = $ex.getId ();
02475                 throw new org.omg.CORBA.MARSHAL (_id);
02476             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02477                 return ddcGetCrateParameterFloat (crate, name        );
02478             } finally {
02479                 _releaseReply ($in);
02480             }
02481   } // ddcGetCrateParameterFloat
02482 
02483 
02484   // SingleTimeout
02485   public String ddcGetCrateParameterString (int crate, String name)
02486   {
02487             org.omg.CORBA.portable.InputStream $in = null;
02488             try {
02489                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetCrateParameterString", true);
02490                 $out.write_long (crate);
02491                 $out.write_string (name);
02492                 $in = _invoke ($out);
02493                 String $result = $in.read_string ();
02494                 return $result;
02495             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02496                 $in = $ex.getInputStream ();
02497                 String _id = $ex.getId ();
02498                 throw new org.omg.CORBA.MARSHAL (_id);
02499             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02500                 return ddcGetCrateParameterString (crate, name        );
02501             } finally {
02502                 _releaseReply ($in);
02503             }
02504   } // ddcGetCrateParameterString
02505 
02506 
02507   // SingleTimeout
02508   public void ddcGetCrateParameters (int crate, String[] names, Sct_SctApi.NameValueListHolder nameValues)
02509   {
02510             org.omg.CORBA.portable.InputStream $in = null;
02511             try {
02512                 org.omg.CORBA.portable.OutputStream $out = _request ("ddcGetCrateParameters", true);
02513                 $out.write_long (crate);
02514                 Sct_SctApi.NameListHelper.write ($out, names);
02515                 $in = _invoke ($out);
02516                 nameValues.value = Sct_SctApi.NameValueListHelper.read ($in);
02517                 return;
02518             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02519                 $in = $ex.getInputStream ();
02520                 String _id = $ex.getId ();
02521                 throw new org.omg.CORBA.MARSHAL (_id);
02522             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02523                 ddcGetCrateParameters (crate, names, nameValues        );
02524             } finally {
02525                 _releaseReply ($in);
02526             }
02527   } // ddcGetCrateParameters
02528 
02529 
02530   // Also set DDC parameters...
02531   public Sct_SctApi.Scan createScan ()
02532   {
02533             org.omg.CORBA.portable.InputStream $in = null;
02534             try {
02535                 org.omg.CORBA.portable.OutputStream $out = _request ("createScan", true);
02536                 $in = _invoke ($out);
02537                 Sct_SctApi.Scan $result = Sct_SctApi.ScanHelper.read ($in);
02538                 return $result;
02539             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02540                 $in = $ex.getInputStream ();
02541                 String _id = $ex.getId ();
02542                 throw new org.omg.CORBA.MARSHAL (_id);
02543             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02544                 return createScan (        );
02545             } finally {
02546                 _releaseReply ($in);
02547             }
02548   } // createScan
02549 
02550   public Sct_SctApi.Scan getDefaultScan ()
02551   {
02552             org.omg.CORBA.portable.InputStream $in = null;
02553             try {
02554                 org.omg.CORBA.portable.OutputStream $out = _request ("getDefaultScan", true);
02555                 $in = _invoke ($out);
02556                 Sct_SctApi.Scan $result = Sct_SctApi.ScanHelper.read ($in);
02557                 return $result;
02558             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02559                 $in = $ex.getInputStream ();
02560                 String _id = $ex.getId ();
02561                 throw new org.omg.CORBA.MARSHAL (_id);
02562             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02563                 return getDefaultScan (        );
02564             } finally {
02565                 _releaseReply ($in);
02566             }
02567   } // getDefaultScan
02568 
02569   public Sct_SctApi.Trigger createTrigger ()
02570   {
02571             org.omg.CORBA.portable.InputStream $in = null;
02572             try {
02573                 org.omg.CORBA.portable.OutputStream $out = _request ("createTrigger", true);
02574                 $in = _invoke ($out);
02575                 Sct_SctApi.Trigger $result = Sct_SctApi.TriggerHelper.read ($in);
02576                 return $result;
02577             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02578                 $in = $ex.getInputStream ();
02579                 String _id = $ex.getId ();
02580                 throw new org.omg.CORBA.MARSHAL (_id);
02581             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02582                 return createTrigger (        );
02583             } finally {
02584                 _releaseReply ($in);
02585             }
02586   } // createTrigger
02587 
02588   public Sct_SctApi.Trigger getDefaultTrigger ()
02589   {
02590             org.omg.CORBA.portable.InputStream $in = null;
02591             try {
02592                 org.omg.CORBA.portable.OutputStream $out = _request ("getDefaultTrigger", true);
02593                 $in = _invoke ($out);
02594                 Sct_SctApi.Trigger $result = Sct_SctApi.TriggerHelper.read ($in);
02595                 return $result;
02596             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02597                 $in = $ex.getInputStream ();
02598                 String _id = $ex.getId ();
02599                 throw new org.omg.CORBA.MARSHAL (_id);
02600             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02601                 return getDefaultTrigger (        );
02602             } finally {
02603                 _releaseReply ($in);
02604             }
02605   } // getDefaultTrigger
02606 
02607   public Sct_SctApi.Scan[] knownScans ()
02608   {
02609             org.omg.CORBA.portable.InputStream $in = null;
02610             try {
02611                 org.omg.CORBA.portable.OutputStream $out = _request ("knownScans", true);
02612                 $in = _invoke ($out);
02613                 Sct_SctApi.Scan $result[] = Sct_SctApi.ScanListHelper.read ($in);
02614                 return $result;
02615             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02616                 $in = $ex.getInputStream ();
02617                 String _id = $ex.getId ();
02618                 throw new org.omg.CORBA.MARSHAL (_id);
02619             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02620                 return knownScans (        );
02621             } finally {
02622                 _releaseReply ($in);
02623             }
02624   } // knownScans
02625 
02626   public void get_info (ipc.InfoHolder inf)
02627   {
02628             org.omg.CORBA.portable.InputStream $in = null;
02629             try {
02630                 org.omg.CORBA.portable.OutputStream $out = _request ("get_info", true);
02631                 $in = _invoke ($out);
02632                 inf.value = ipc.InfoHelper.read ($in);
02633                 return;
02634             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02635                 $in = $ex.getInputStream ();
02636                 String _id = $ex.getId ();
02637                 throw new org.omg.CORBA.MARSHAL (_id);
02638             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02639                 get_info (inf        );
02640             } finally {
02641                 _releaseReply ($in);
02642             }
02643   } // get_info
02644 
02645   public void destroy ()
02646   {
02647             org.omg.CORBA.portable.InputStream $in = null;
02648             try {
02649                 org.omg.CORBA.portable.OutputStream $out = _request ("destroy", false);
02650                 $in = _invoke ($out);
02651                 return;
02652             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02653                 $in = $ex.getInputStream ();
02654                 String _id = $ex.getId ();
02655                 throw new org.omg.CORBA.MARSHAL (_id);
02656             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02657                 destroy (        );
02658             } finally {
02659                 _releaseReply ($in);
02660             }
02661   } // destroy
02662 
02663   // Type-specific CORBA::Object operations
02664   private static String[] __ids = {
02665     "IDL:Sct_SctApi/SctApi:1.0", 
02666     "IDL:ipc/freeable:1.0"};
02667 
02668   public String[] _ids ()
02669   {
02670     return (String[])__ids.clone ();
02671   }
02672 
02673   private void readObject (java.io.ObjectInputStream s) throws java.io.IOException
02674   {
02675      String str = s.readUTF ();
02676      String[] args = null;
02677      java.util.Properties props = null;
02678      org.omg.CORBA.Object obj = org.omg.CORBA.ORB.init (args, props).string_to_object (str);
02679      org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl) obj)._get_delegate ();
02680      _set_delegate (delegate);
02681   }
02682 
02683   private void writeObject (java.io.ObjectOutputStream s) throws java.io.IOException
02684   {
02685      String[] args = null;
02686      java.util.Properties props = null;
02687      String str = org.omg.CORBA.ORB.init (args, props).object_to_string (this);
02688      s.writeUTF (str);
02689   }
02690 } // class _SctApiStub

Generated on Sat Jul 31 14:20:53 2004 for SCT DAQ/DCS Software - Java by doxygen 1.3.5