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

_ConfigurationStub.java

00001 package sctConf;
00002 
00003 
00011 public class _ConfigurationStub extends org.omg.CORBA.portable.ObjectImpl implements sctConf.Configuration
00012 {
00013 
00014 
00015   //     string getLocation();
00016   public int[] listPartitions () throws sctConf.ConfigurationException
00017   {
00018             org.omg.CORBA.portable.InputStream $in = null;
00019             try {
00020                 org.omg.CORBA.portable.OutputStream $out = _request ("listPartitions", true);
00021                 $in = _invoke ($out);
00022                 int $result[] = sctConf.PartitionListHelper.read ($in);
00023                 return $result;
00024             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00025                 $in = $ex.getInputStream ();
00026                 String _id = $ex.getId ();
00027                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00028                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00029                 else
00030                     throw new org.omg.CORBA.MARSHAL (_id);
00031             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00032                 return listPartitions (        );
00033             } finally {
00034                 _releaseReply ($in);
00035             }
00036   } // listPartitions
00037 
00038   public int[] listCratesInPartition (int partition) throws sctConf.ConfigurationException
00039   {
00040             org.omg.CORBA.portable.InputStream $in = null;
00041             try {
00042                 org.omg.CORBA.portable.OutputStream $out = _request ("listCratesInPartition", true);
00043                 $out.write_ulong (partition);
00044                 $in = _invoke ($out);
00045                 int $result[] = sctConf.CrateListHelper.read ($in);
00046                 return $result;
00047             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00048                 $in = $ex.getInputStream ();
00049                 String _id = $ex.getId ();
00050                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00051                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00052                 else
00053                     throw new org.omg.CORBA.MARSHAL (_id);
00054             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00055                 return listCratesInPartition (partition        );
00056             } finally {
00057                 _releaseReply ($in);
00058             }
00059   } // listCratesInPartition
00060 
00061   public boolean isDummyCrate (int partition, int crate)
00062   {
00063             org.omg.CORBA.portable.InputStream $in = null;
00064             try {
00065                 org.omg.CORBA.portable.OutputStream $out = _request ("isDummyCrate", true);
00066                 $out.write_ulong (partition);
00067                 $out.write_ulong (crate);
00068                 $in = _invoke ($out);
00069                 boolean $result = $in.read_boolean ();
00070                 return $result;
00071             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00072                 $in = $ex.getInputStream ();
00073                 String _id = $ex.getId ();
00074                 throw new org.omg.CORBA.MARSHAL (_id);
00075             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00076                 return isDummyCrate (partition, crate        );
00077             } finally {
00078                 _releaseReply ($in);
00079             }
00080   } // isDummyCrate
00081 
00082   public int[] listRodsInCrate (int partition, int crate) throws sctConf.ConfigurationException
00083   {
00084             org.omg.CORBA.portable.InputStream $in = null;
00085             try {
00086                 org.omg.CORBA.portable.OutputStream $out = _request ("listRodsInCrate", true);
00087                 $out.write_ulong (partition);
00088                 $out.write_ulong (crate);
00089                 $in = _invoke ($out);
00090                 int $result[] = sctConf.RodListHelper.read ($in);
00091                 return $result;
00092             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00093                 $in = $ex.getInputStream ();
00094                 String _id = $ex.getId ();
00095                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00096                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00097                 else
00098                     throw new org.omg.CORBA.MARSHAL (_id);
00099             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00100                 return listRodsInCrate (partition, crate        );
00101             } finally {
00102                 _releaseReply ($in);
00103             }
00104   } // listRodsInCrate
00105 
00106   public int[] listMURSInRod (int partition, int crate, int rod) throws sctConf.ConfigurationException
00107   {
00108             org.omg.CORBA.portable.InputStream $in = null;
00109             try {
00110                 org.omg.CORBA.portable.OutputStream $out = _request ("listMURSInRod", true);
00111                 $out.write_ulong (partition);
00112                 $out.write_ulong (crate);
00113                 $out.write_ulong (rod);
00114                 $in = _invoke ($out);
00115                 int $result[] = sctConf.MURListHelper.read ($in);
00116                 return $result;
00117             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00118                 $in = $ex.getInputStream ();
00119                 String _id = $ex.getId ();
00120                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00121                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00122                 else
00123                     throw new org.omg.CORBA.MARSHAL (_id);
00124             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00125                 return listMURSInRod (partition, crate, rod        );
00126             } finally {
00127                 _releaseReply ($in);
00128             }
00129   } // listMURSInRod
00130 
00131   public String[] listModulesInMUR (int partition, int MUR) throws sctConf.ConfigurationException
00132   {
00133             org.omg.CORBA.portable.InputStream $in = null;
00134             try {
00135                 org.omg.CORBA.portable.OutputStream $out = _request ("listModulesInMUR", true);
00136                 $out.write_ulong (partition);
00137                 $out.write_ulong (MUR);
00138                 $in = _invoke ($out);
00139                 String $result[] = sctConf.ModuleListHelper.read ($in);
00140                 return $result;
00141             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00142                 $in = $ex.getInputStream ();
00143                 String _id = $ex.getId ();
00144                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00145                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00146                 else
00147                     throw new org.omg.CORBA.MARSHAL (_id);
00148             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00149                 return listModulesInMUR (partition, MUR        );
00150             } finally {
00151                 _releaseReply ($in);
00152             }
00153   } // listModulesInMUR
00154 
00155   public String[] listRModulesInMUR (int partition, int MUR) throws sctConf.ConfigurationException
00156   {
00157             org.omg.CORBA.portable.InputStream $in = null;
00158             try {
00159                 org.omg.CORBA.portable.OutputStream $out = _request ("listRModulesInMUR", true);
00160                 $out.write_ulong (partition);
00161                 $out.write_ulong (MUR);
00162                 $in = _invoke ($out);
00163                 String $result[] = sctConf.ModuleListHelper.read ($in);
00164                 return $result;
00165             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00166                 $in = $ex.getInputStream ();
00167                 String _id = $ex.getId ();
00168                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00169                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00170                 else
00171                     throw new org.omg.CORBA.MARSHAL (_id);
00172             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00173                 return listRModulesInMUR (partition, MUR        );
00174             } finally {
00175                 _releaseReply ($in);
00176             }
00177   } // listRModulesInMUR
00178 
00179   public String[] listAllModules () throws sctConf.ConfigurationException
00180   {
00181             org.omg.CORBA.portable.InputStream $in = null;
00182             try {
00183                 org.omg.CORBA.portable.OutputStream $out = _request ("listAllModules", true);
00184                 $in = _invoke ($out);
00185                 String $result[] = sctConf.ModuleListHelper.read ($in);
00186                 return $result;
00187             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00188                 $in = $ex.getInputStream ();
00189                 String _id = $ex.getId ();
00190                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00191                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00192                 else
00193                     throw new org.omg.CORBA.MARSHAL (_id);
00194             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00195                 return listAllModules (        );
00196             } finally {
00197                 _releaseReply ($in);
00198             }
00199   } // listAllModules
00200 
00201   public String[] listUnusedModules () throws sctConf.ConfigurationException
00202   {
00203             org.omg.CORBA.portable.InputStream $in = null;
00204             try {
00205                 org.omg.CORBA.portable.OutputStream $out = _request ("listUnusedModules", true);
00206                 $in = _invoke ($out);
00207                 String $result[] = sctConf.ModuleListHelper.read ($in);
00208                 return $result;
00209             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00210                 $in = $ex.getInputStream ();
00211                 String _id = $ex.getId ();
00212                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00213                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00214                 else
00215                     throw new org.omg.CORBA.MARSHAL (_id);
00216             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00217                 return listUnusedModules (        );
00218             } finally {
00219                 _releaseReply ($in);
00220             }
00221   } // listUnusedModules
00222 
00223   public sctConf.ABCDModule getModuleConfig (String mod) throws sctConf.ConfigurationException
00224   {
00225             org.omg.CORBA.portable.InputStream $in = null;
00226             try {
00227                 org.omg.CORBA.portable.OutputStream $out = _request ("getModuleConfig", true);
00228                 $out.write_string (mod);
00229                 $in = _invoke ($out);
00230                 sctConf.ABCDModule $result = sctConf.ABCDModuleHelper.read ($in);
00231                 return $result;
00232             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00233                 $in = $ex.getInputStream ();
00234                 String _id = $ex.getId ();
00235                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00236                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00237                 else
00238                     throw new org.omg.CORBA.MARSHAL (_id);
00239             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00240                 return getModuleConfig (mod        );
00241             } finally {
00242                 _releaseReply ($in);
00243             }
00244   } // getModuleConfig
00245 
00246   public short getModuleGroup (String mod) throws sctConf.ConfigurationException
00247   {
00248             org.omg.CORBA.portable.InputStream $in = null;
00249             try {
00250                 org.omg.CORBA.portable.OutputStream $out = _request ("getModuleGroup", true);
00251                 $out.write_string (mod);
00252                 $in = _invoke ($out);
00253                 short $result = $in.read_ushort ();
00254                 return $result;
00255             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00256                 $in = $ex.getInputStream ();
00257                 String _id = $ex.getId ();
00258                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00259                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00260                 else
00261                     throw new org.omg.CORBA.MARSHAL (_id);
00262             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00263                 return getModuleGroup (mod        );
00264             } finally {
00265                 _releaseReply ($in);
00266             }
00267   } // getModuleGroup
00268 
00269   public void setModuleGroup (String mod, short group) throws sctConf.ConfigurationException
00270   {
00271             org.omg.CORBA.portable.InputStream $in = null;
00272             try {
00273                 org.omg.CORBA.portable.OutputStream $out = _request ("setModuleGroup", true);
00274                 $out.write_string (mod);
00275                 $out.write_short (group);
00276                 $in = _invoke ($out);
00277                 return;
00278             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00279                 $in = $ex.getInputStream ();
00280                 String _id = $ex.getId ();
00281                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00282                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00283                 else
00284                     throw new org.omg.CORBA.MARSHAL (_id);
00285             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00286                 setModuleGroup (mod, group        );
00287             } finally {
00288                 _releaseReply ($in);
00289             }
00290   } // setModuleGroup
00291 
00292   public sctConf.RodConfig getRodConfig (int partition, int crate, int rod) throws sctConf.ConfigurationException
00293   {
00294             org.omg.CORBA.portable.InputStream $in = null;
00295             try {
00296                 org.omg.CORBA.portable.OutputStream $out = _request ("getRodConfig", true);
00297                 $out.write_ulong (partition);
00298                 $out.write_ulong (crate);
00299                 $out.write_ulong (rod);
00300                 $in = _invoke ($out);
00301                 sctConf.RodConfig $result = sctConf.RodConfigHelper.read ($in);
00302                 return $result;
00303             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00304                 $in = $ex.getInputStream ();
00305                 String _id = $ex.getId ();
00306                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00307                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00308                 else
00309                     throw new org.omg.CORBA.MARSHAL (_id);
00310             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00311                 return getRodConfig (partition, crate, rod        );
00312             } finally {
00313                 _releaseReply ($in);
00314             }
00315   } // getRodConfig
00316 
00317   public sctConf.SlaveConfig getDefaultSlaveConfig (byte type) throws sctConf.ConfigurationException
00318   {
00319             org.omg.CORBA.portable.InputStream $in = null;
00320             try {
00321                 org.omg.CORBA.portable.OutputStream $out = _request ("getDefaultSlaveConfig", true);
00322                 $out.write_octet (type);
00323                 $in = _invoke ($out);
00324                 sctConf.SlaveConfig $result = sctConf.SlaveConfigHelper.read ($in);
00325                 return $result;
00326             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00327                 $in = $ex.getInputStream ();
00328                 String _id = $ex.getId ();
00329                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00330                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00331                 else
00332                     throw new org.omg.CORBA.MARSHAL (_id);
00333             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00334                 return getDefaultSlaveConfig (type        );
00335             } finally {
00336                 _releaseReply ($in);
00337             }
00338   } // getDefaultSlaveConfig
00339 
00340   public sctConf.TimConfig getTimConfig (int partition, int crate) throws sctConf.ConfigurationException
00341   {
00342             org.omg.CORBA.portable.InputStream $in = null;
00343             try {
00344                 org.omg.CORBA.portable.OutputStream $out = _request ("getTimConfig", true);
00345                 $out.write_ulong (partition);
00346                 $out.write_ulong (crate);
00347                 $in = _invoke ($out);
00348                 sctConf.TimConfig $result = sctConf.TimConfigHelper.read ($in);
00349                 return $result;
00350             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00351                 $in = $ex.getInputStream ();
00352                 String _id = $ex.getId ();
00353                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00354                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00355                 else
00356                     throw new org.omg.CORBA.MARSHAL (_id);
00357             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00358                 return getTimConfig (partition, crate        );
00359             } finally {
00360                 _releaseReply ($in);
00361             }
00362   } // getTimConfig
00363 
00364 
00365   // These should be unsigned (for comparison with 255)
00366   public byte[] getFibreMappings (int partition, int crate, int rod) throws sctConf.ConfigurationException
00367   {
00368             org.omg.CORBA.portable.InputStream $in = null;
00369             try {
00370                 org.omg.CORBA.portable.OutputStream $out = _request ("getFibreMappings", true);
00371                 $out.write_ulong (partition);
00372                 $out.write_ulong (crate);
00373                 $out.write_ulong (rod);
00374                 $in = _invoke ($out);
00375                 byte $result[] = sctConf.CharBlockHelper.read ($in);
00376                 return $result;
00377             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00378                 $in = $ex.getInputStream ();
00379                 String _id = $ex.getId ();
00380                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00381                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00382                 else
00383                     throw new org.omg.CORBA.MARSHAL (_id);
00384             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00385                 return getFibreMappings (partition, crate, rod        );
00386             } finally {
00387                 _releaseReply ($in);
00388             }
00389   } // getFibreMappings
00390 
00391   public void setFibreMapping (int partition, int crate, int rod, int channel, int tx, int rx0, int rx1) throws sctConf.ConfigurationException
00392   {
00393             org.omg.CORBA.portable.InputStream $in = null;
00394             try {
00395                 org.omg.CORBA.portable.OutputStream $out = _request ("setFibreMapping", true);
00396                 $out.write_ulong (partition);
00397                 $out.write_ulong (crate);
00398                 $out.write_ulong (rod);
00399                 $out.write_ulong (channel);
00400                 $out.write_ulong (tx);
00401                 $out.write_ulong (rx0);
00402                 $out.write_ulong (rx1);
00403                 $in = _invoke ($out);
00404                 return;
00405             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00406                 $in = $ex.getInputStream ();
00407                 String _id = $ex.getId ();
00408                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00409                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00410                 else
00411                     throw new org.omg.CORBA.MARSHAL (_id);
00412             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00413                 setFibreMapping (partition, crate, rod, channel, tx, rx0, rx1        );
00414             } finally {
00415                 _releaseReply ($in);
00416             }
00417   } // setFibreMapping
00418 
00419   public sctConf.BOCChannelConfig getBOCConfig (int partition, int crate, int rod, int channel) throws sctConf.ConfigurationException
00420   {
00421             org.omg.CORBA.portable.InputStream $in = null;
00422             try {
00423                 org.omg.CORBA.portable.OutputStream $out = _request ("getBOCConfig", true);
00424                 $out.write_ulong (partition);
00425                 $out.write_ulong (crate);
00426                 $out.write_ulong (rod);
00427                 $out.write_ulong (channel);
00428                 $in = _invoke ($out);
00429                 sctConf.BOCChannelConfig $result = sctConf.BOCChannelConfigHelper.read ($in);
00430                 return $result;
00431             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00432                 $in = $ex.getInputStream ();
00433                 String _id = $ex.getId ();
00434                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00435                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00436                 else
00437                     throw new org.omg.CORBA.MARSHAL (_id);
00438             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00439                 return getBOCConfig (partition, crate, rod, channel        );
00440             } finally {
00441                 _releaseReply ($in);
00442             }
00443   } // getBOCConfig
00444 
00445   public sctConf.BOCGlobalConfig getBOCGlobalConfig (int partition, int crate, int rod) throws sctConf.ConfigurationException
00446   {
00447             org.omg.CORBA.portable.InputStream $in = null;
00448             try {
00449                 org.omg.CORBA.portable.OutputStream $out = _request ("getBOCGlobalConfig", true);
00450                 $out.write_ulong (partition);
00451                 $out.write_ulong (crate);
00452                 $out.write_ulong (rod);
00453                 $in = _invoke ($out);
00454                 sctConf.BOCGlobalConfig $result = sctConf.BOCGlobalConfigHelper.read ($in);
00455                 return $result;
00456             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00457                 $in = $ex.getInputStream ();
00458                 String _id = $ex.getId ();
00459                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00460                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00461                 else
00462                     throw new org.omg.CORBA.MARSHAL (_id);
00463             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00464                 return getBOCGlobalConfig (partition, crate, rod        );
00465             } finally {
00466                 _releaseReply ($in);
00467             }
00468   } // getBOCGlobalConfig
00469 
00470   public void printModuleConfig (sctConf.ABCDModule conf) throws sctConf.ConfigurationException
00471   {
00472             org.omg.CORBA.portable.InputStream $in = null;
00473             try {
00474                 org.omg.CORBA.portable.OutputStream $out = _request ("printModuleConfig", true);
00475                 sctConf.ABCDModuleHelper.write ($out, conf);
00476                 $in = _invoke ($out);
00477                 return;
00478             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00479                 $in = $ex.getInputStream ();
00480                 String _id = $ex.getId ();
00481                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00482                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00483                 else
00484                     throw new org.omg.CORBA.MARSHAL (_id);
00485             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00486                 printModuleConfig (conf        );
00487             } finally {
00488                 _releaseReply ($in);
00489             }
00490   } // printModuleConfig
00491 
00492   public sctConf.MURType getMURType (int MUR) throws sctConf.ConfigurationException
00493   {
00494             org.omg.CORBA.portable.InputStream $in = null;
00495             try {
00496                 org.omg.CORBA.portable.OutputStream $out = _request ("getMURType", true);
00497                 $out.write_ulong (MUR);
00498                 $in = _invoke ($out);
00499                 sctConf.MURType $result = sctConf.MURTypeHelper.read ($in);
00500                 return $result;
00501             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00502                 $in = $ex.getInputStream ();
00503                 String _id = $ex.getId ();
00504                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00505                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00506                 else
00507                     throw new org.omg.CORBA.MARSHAL (_id);
00508             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00509                 return getMURType (MUR        );
00510             } finally {
00511                 _releaseReply ($in);
00512             }
00513   } // getMURType
00514 
00515   public int getFreeMurId () throws sctConf.ConfigurationException
00516   {
00517             org.omg.CORBA.portable.InputStream $in = null;
00518             try {
00519                 org.omg.CORBA.portable.OutputStream $out = _request ("getFreeMurId", true);
00520                 $in = _invoke ($out);
00521                 int $result = $in.read_ulong ();
00522                 return $result;
00523             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00524                 $in = $ex.getInputStream ();
00525                 String _id = $ex.getId ();
00526                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00527                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00528                 else
00529                     throw new org.omg.CORBA.MARSHAL (_id);
00530             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00531                 return getFreeMurId (        );
00532             } finally {
00533                 _releaseReply ($in);
00534             }
00535   } // getFreeMurId
00536 
00537   public void translateToROD (int MUR, int mod, org.omg.CORBA.IntHolder partition, org.omg.CORBA.IntHolder crate, org.omg.CORBA.IntHolder rod, org.omg.CORBA.IntHolder channel) throws sctConf.ConfigurationException
00538   {
00539             org.omg.CORBA.portable.InputStream $in = null;
00540             try {
00541                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToROD", true);
00542                 $out.write_ulong (MUR);
00543                 $out.write_ulong (mod);
00544                 $in = _invoke ($out);
00545                 partition.value = $in.read_ulong ();
00546                 crate.value = $in.read_ulong ();
00547                 rod.value = $in.read_ulong ();
00548                 channel.value = $in.read_ulong ();
00549                 return;
00550             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00551                 $in = $ex.getInputStream ();
00552                 String _id = $ex.getId ();
00553                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00554                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00555                 else
00556                     throw new org.omg.CORBA.MARSHAL (_id);
00557             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00558                 translateToROD (MUR, mod, partition, crate, rod, channel        );
00559             } finally {
00560                 _releaseReply ($in);
00561             }
00562   } // translateToROD
00563 
00564   public void translateToRROD (int MUR, int mod, org.omg.CORBA.IntHolder partition, org.omg.CORBA.IntHolder crate, org.omg.CORBA.IntHolder rod, org.omg.CORBA.IntHolder channel) throws sctConf.ConfigurationException
00565   {
00566             org.omg.CORBA.portable.InputStream $in = null;
00567             try {
00568                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToRROD", true);
00569                 $out.write_ulong (MUR);
00570                 $out.write_ulong (mod);
00571                 $in = _invoke ($out);
00572                 partition.value = $in.read_ulong ();
00573                 crate.value = $in.read_ulong ();
00574                 rod.value = $in.read_ulong ();
00575                 channel.value = $in.read_ulong ();
00576                 return;
00577             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00578                 $in = $ex.getInputStream ();
00579                 String _id = $ex.getId ();
00580                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00581                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00582                 else
00583                     throw new org.omg.CORBA.MARSHAL (_id);
00584             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00585                 translateToRROD (MUR, mod, partition, crate, rod, channel        );
00586             } finally {
00587                 _releaseReply ($in);
00588             }
00589   } // translateToRROD
00590 
00591   public void translateToSN (int MUR, int mod, org.omg.CORBA.StringHolder sn) throws sctConf.ConfigurationException
00592   {
00593             org.omg.CORBA.portable.InputStream $in = null;
00594             try {
00595                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToSN", true);
00596                 $out.write_ulong (MUR);
00597                 $out.write_ulong (mod);
00598                 $in = _invoke ($out);
00599                 sn.value = $in.read_string ();
00600                 return;
00601             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00602                 $in = $ex.getInputStream ();
00603                 String _id = $ex.getId ();
00604                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00605                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00606                 else
00607                     throw new org.omg.CORBA.MARSHAL (_id);
00608             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00609                 translateToSN (MUR, mod, sn        );
00610             } finally {
00611                 _releaseReply ($in);
00612             }
00613   } // translateToSN
00614 
00615   public void translateToRMUR (int RMUR, int rmod, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00616   {
00617             org.omg.CORBA.portable.InputStream $in = null;
00618             try {
00619                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToRMUR", true);
00620                 $out.write_ulong (RMUR);
00621                 $out.write_ulong (rmod);
00622                 $in = _invoke ($out);
00623                 MUR.value = $in.read_ulong ();
00624                 mod.value = $in.read_ulong ();
00625                 return;
00626             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00627                 $in = $ex.getInputStream ();
00628                 String _id = $ex.getId ();
00629                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00630                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00631                 else
00632                     throw new org.omg.CORBA.MARSHAL (_id);
00633             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00634                 translateToRMUR (RMUR, rmod, MUR, mod        );
00635             } finally {
00636                 _releaseReply ($in);
00637             }
00638   } // translateToRMUR
00639 
00640   public void translateToBarrel (int MUR, int mod, org.omg.CORBA.IntHolder barrel, org.omg.CORBA.IntHolder row, org.omg.CORBA.IntHolder number) throws sctConf.ConfigurationException
00641   {
00642             org.omg.CORBA.portable.InputStream $in = null;
00643             try {
00644                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToBarrel", true);
00645                 $out.write_ulong (MUR);
00646                 $out.write_ulong (mod);
00647                 $in = _invoke ($out);
00648                 barrel.value = $in.read_ulong ();
00649                 row.value = $in.read_ulong ();
00650                 number.value = $in.read_long ();
00651                 return;
00652             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00653                 $in = $ex.getInputStream ();
00654                 String _id = $ex.getId ();
00655                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00656                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00657                 else
00658                     throw new org.omg.CORBA.MARSHAL (_id);
00659             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00660                 translateToBarrel (MUR, mod, barrel, row, number        );
00661             } finally {
00662                 _releaseReply ($in);
00663             }
00664   } // translateToBarrel
00665 
00666   public void translateToEndcap (int MUR, int mod, org.omg.CORBA.IntHolder disk, org.omg.CORBA.IntHolder ring, org.omg.CORBA.IntHolder number) throws sctConf.ConfigurationException
00667   {
00668             org.omg.CORBA.portable.InputStream $in = null;
00669             try {
00670                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToEndcap", true);
00671                 $out.write_ulong (MUR);
00672                 $out.write_ulong (mod);
00673                 $in = _invoke ($out);
00674                 disk.value = $in.read_long ();
00675                 ring.value = $in.read_ulong ();
00676                 number.value = $in.read_ulong ();
00677                 return;
00678             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00679                 $in = $ex.getInputStream ();
00680                 String _id = $ex.getId ();
00681                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00682                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00683                 else
00684                     throw new org.omg.CORBA.MARSHAL (_id);
00685             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00686                 translateToEndcap (MUR, mod, disk, ring, number        );
00687             } finally {
00688                 _releaseReply ($in);
00689             }
00690   } // translateToEndcap
00691 
00692   public void translateToPowerSupply (int MUR, int mod, org.omg.CORBA.IntHolder partition, org.omg.CORBA.IntHolder crate, org.omg.CORBA.IntHolder channel) throws sctConf.ConfigurationException
00693   {
00694             org.omg.CORBA.portable.InputStream $in = null;
00695             try {
00696                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToPowerSupply", true);
00697                 $out.write_ulong (MUR);
00698                 $out.write_ulong (mod);
00699                 $in = _invoke ($out);
00700                 partition.value = $in.read_ulong ();
00701                 crate.value = $in.read_ulong ();
00702                 channel.value = $in.read_ulong ();
00703                 return;
00704             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00705                 $in = $ex.getInputStream ();
00706                 String _id = $ex.getId ();
00707                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00708                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00709                 else
00710                     throw new org.omg.CORBA.MARSHAL (_id);
00711             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00712                 translateToPowerSupply (MUR, mod, partition, crate, channel        );
00713             } finally {
00714                 _releaseReply ($in);
00715             }
00716   } // translateToPowerSupply
00717 
00718   public void translateFromROD (int partition, int crate, int rod, int channel, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00719   {
00720             org.omg.CORBA.portable.InputStream $in = null;
00721             try {
00722                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromROD", true);
00723                 $out.write_ulong (partition);
00724                 $out.write_ulong (crate);
00725                 $out.write_ulong (rod);
00726                 $out.write_ulong (channel);
00727                 $in = _invoke ($out);
00728                 MUR.value = $in.read_ulong ();
00729                 mod.value = $in.read_ulong ();
00730                 return;
00731             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00732                 $in = $ex.getInputStream ();
00733                 String _id = $ex.getId ();
00734                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00735                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00736                 else
00737                     throw new org.omg.CORBA.MARSHAL (_id);
00738             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00739                 translateFromROD (partition, crate, rod, channel, MUR, mod        );
00740             } finally {
00741                 _releaseReply ($in);
00742             }
00743   } // translateFromROD
00744 
00745   public void translateFromRROD (int partition, int crate, int rod, int channel, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00746   {
00747             org.omg.CORBA.portable.InputStream $in = null;
00748             try {
00749                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromRROD", true);
00750                 $out.write_ulong (partition);
00751                 $out.write_ulong (crate);
00752                 $out.write_ulong (rod);
00753                 $out.write_ulong (channel);
00754                 $in = _invoke ($out);
00755                 MUR.value = $in.read_ulong ();
00756                 mod.value = $in.read_ulong ();
00757                 return;
00758             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00759                 $in = $ex.getInputStream ();
00760                 String _id = $ex.getId ();
00761                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00762                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00763                 else
00764                     throw new org.omg.CORBA.MARSHAL (_id);
00765             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00766                 translateFromRROD (partition, crate, rod, channel, MUR, mod        );
00767             } finally {
00768                 _releaseReply ($in);
00769             }
00770   } // translateFromRROD
00771 
00772   public void translateFromSN (String sn, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00773   {
00774             org.omg.CORBA.portable.InputStream $in = null;
00775             try {
00776                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromSN", true);
00777                 $out.write_string (sn);
00778                 $in = _invoke ($out);
00779                 MUR.value = $in.read_ulong ();
00780                 mod.value = $in.read_ulong ();
00781                 return;
00782             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00783                 $in = $ex.getInputStream ();
00784                 String _id = $ex.getId ();
00785                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00786                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00787                 else
00788                     throw new org.omg.CORBA.MARSHAL (_id);
00789             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00790                 translateFromSN (sn, MUR, mod        );
00791             } finally {
00792                 _releaseReply ($in);
00793             }
00794   } // translateFromSN
00795 
00796   public void translateFromRMUR (int MUR, int mod, org.omg.CORBA.IntHolder RMUR, org.omg.CORBA.IntHolder rmod) throws sctConf.ConfigurationException
00797   {
00798             org.omg.CORBA.portable.InputStream $in = null;
00799             try {
00800                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromRMUR", true);
00801                 $out.write_ulong (MUR);
00802                 $out.write_ulong (mod);
00803                 $in = _invoke ($out);
00804                 RMUR.value = $in.read_ulong ();
00805                 rmod.value = $in.read_ulong ();
00806                 return;
00807             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00808                 $in = $ex.getInputStream ();
00809                 String _id = $ex.getId ();
00810                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00811                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00812                 else
00813                     throw new org.omg.CORBA.MARSHAL (_id);
00814             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00815                 translateFromRMUR (MUR, mod, RMUR, rmod        );
00816             } finally {
00817                 _releaseReply ($in);
00818             }
00819   } // translateFromRMUR
00820 
00821   public void translateFromBarrel (int barrel, int row, int number, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00822   {
00823             org.omg.CORBA.portable.InputStream $in = null;
00824             try {
00825                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromBarrel", true);
00826                 $out.write_ulong (barrel);
00827                 $out.write_ulong (row);
00828                 $out.write_long (number);
00829                 $in = _invoke ($out);
00830                 MUR.value = $in.read_ulong ();
00831                 mod.value = $in.read_ulong ();
00832                 return;
00833             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00834                 $in = $ex.getInputStream ();
00835                 String _id = $ex.getId ();
00836                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00837                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00838                 else
00839                     throw new org.omg.CORBA.MARSHAL (_id);
00840             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00841                 translateFromBarrel (barrel, row, number, MUR, mod        );
00842             } finally {
00843                 _releaseReply ($in);
00844             }
00845   } // translateFromBarrel
00846 
00847   public void translateFromEndcap (int disk, int ring, int number, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00848   {
00849             org.omg.CORBA.portable.InputStream $in = null;
00850             try {
00851                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromEndcap", true);
00852                 $out.write_long (disk);
00853                 $out.write_ulong (ring);
00854                 $out.write_ulong (number);
00855                 $in = _invoke ($out);
00856                 MUR.value = $in.read_ulong ();
00857                 mod.value = $in.read_ulong ();
00858                 return;
00859             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00860                 $in = $ex.getInputStream ();
00861                 String _id = $ex.getId ();
00862                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00863                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00864                 else
00865                     throw new org.omg.CORBA.MARSHAL (_id);
00866             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00867                 translateFromEndcap (disk, ring, number, MUR, mod        );
00868             } finally {
00869                 _releaseReply ($in);
00870             }
00871   } // translateFromEndcap
00872 
00873   public void translateFromPowerSupply (int partition, int crate, int channel, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00874   {
00875             org.omg.CORBA.portable.InputStream $in = null;
00876             try {
00877                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromPowerSupply", true);
00878                 $out.write_ulong (partition);
00879                 $out.write_ulong (crate);
00880                 $out.write_ulong (channel);
00881                 $in = _invoke ($out);
00882                 MUR.value = $in.read_ulong ();
00883                 mod.value = $in.read_ulong ();
00884                 return;
00885             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00886                 $in = $ex.getInputStream ();
00887                 String _id = $ex.getId ();
00888                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00889                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00890                 else
00891                     throw new org.omg.CORBA.MARSHAL (_id);
00892             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00893                 translateFromPowerSupply (partition, crate, channel, MUR, mod        );
00894             } finally {
00895                 _releaseReply ($in);
00896             }
00897   } // translateFromPowerSupply
00898 
00899 
00900   //       raises(ConfigurationException);
00901   public void configureModuleFromStructure (String number, sctConf.ABCDModule mConf) throws sctConf.ConfigurationException
00902   {
00903             org.omg.CORBA.portable.InputStream $in = null;
00904             try {
00905                 org.omg.CORBA.portable.OutputStream $out = _request ("configureModuleFromStructure", true);
00906                 $out.write_string (number);
00907                 sctConf.ABCDModuleHelper.write ($out, mConf);
00908                 $in = _invoke ($out);
00909                 return;
00910             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00911                 $in = $ex.getInputStream ();
00912                 String _id = $ex.getId ();
00913                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00914                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00915                 else
00916                     throw new org.omg.CORBA.MARSHAL (_id);
00917             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00918                 configureModuleFromStructure (number, mConf        );
00919             } finally {
00920                 _releaseReply ($in);
00921             }
00922   } // configureModuleFromStructure
00923 
00924   public void configureModuleFromFile (String filename) throws sctConf.ConfigurationException
00925   {
00926             org.omg.CORBA.portable.InputStream $in = null;
00927             try {
00928                 org.omg.CORBA.portable.OutputStream $out = _request ("configureModuleFromFile", true);
00929                 $out.write_string (filename);
00930                 $in = _invoke ($out);
00931                 return;
00932             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00933                 $in = $ex.getInputStream ();
00934                 String _id = $ex.getId ();
00935                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00936                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00937                 else
00938                     throw new org.omg.CORBA.MARSHAL (_id);
00939             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00940                 configureModuleFromFile (filename        );
00941             } finally {
00942                 _releaseReply ($in);
00943             }
00944   } // configureModuleFromFile
00945 
00946   public void configureROD (int partition, int crate, int rod, sctConf.RodConfig conf) throws sctConf.ConfigurationException
00947   {
00948             org.omg.CORBA.portable.InputStream $in = null;
00949             try {
00950                 org.omg.CORBA.portable.OutputStream $out = _request ("configureROD", true);
00951                 $out.write_ulong (partition);
00952                 $out.write_ulong (crate);
00953                 $out.write_ulong (rod);
00954                 sctConf.RodConfigHelper.write ($out, conf);
00955                 $in = _invoke ($out);
00956                 return;
00957             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00958                 $in = $ex.getInputStream ();
00959                 String _id = $ex.getId ();
00960                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00961                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00962                 else
00963                     throw new org.omg.CORBA.MARSHAL (_id);
00964             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00965                 configureROD (partition, crate, rod, conf        );
00966             } finally {
00967                 _releaseReply ($in);
00968             }
00969   } // configureROD
00970 
00971   public void configureTIM (int partition, int crate, sctConf.TimConfig conf) throws sctConf.ConfigurationException
00972   {
00973             org.omg.CORBA.portable.InputStream $in = null;
00974             try {
00975                 org.omg.CORBA.portable.OutputStream $out = _request ("configureTIM", true);
00976                 $out.write_ulong (partition);
00977                 $out.write_ulong (crate);
00978                 sctConf.TimConfigHelper.write ($out, conf);
00979                 $in = _invoke ($out);
00980                 return;
00981             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00982                 $in = $ex.getInputStream ();
00983                 String _id = $ex.getId ();
00984                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00985                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00986                 else
00987                     throw new org.omg.CORBA.MARSHAL (_id);
00988             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00989                 configureTIM (partition, crate, conf        );
00990             } finally {
00991                 _releaseReply ($in);
00992             }
00993   } // configureTIM
00994 
00995   public void configureBOC (int partition, int crate, int rod, sctConf.BOCGlobalConfig conf) throws sctConf.ConfigurationException
00996   {
00997             org.omg.CORBA.portable.InputStream $in = null;
00998             try {
00999                 org.omg.CORBA.portable.OutputStream $out = _request ("configureBOC", true);
01000                 $out.write_ulong (partition);
01001                 $out.write_ulong (crate);
01002                 $out.write_ulong (rod);
01003                 sctConf.BOCGlobalConfigHelper.write ($out, conf);
01004                 $in = _invoke ($out);
01005                 return;
01006             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01007                 $in = $ex.getInputStream ();
01008                 String _id = $ex.getId ();
01009                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01010                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01011                 else
01012                     throw new org.omg.CORBA.MARSHAL (_id);
01013             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01014                 configureBOC (partition, crate, rod, conf        );
01015             } finally {
01016                 _releaseReply ($in);
01017             }
01018   } // configureBOC
01019 
01020   public void clearAll () throws sctConf.ConfigurationException
01021   {
01022             org.omg.CORBA.portable.InputStream $in = null;
01023             try {
01024                 org.omg.CORBA.portable.OutputStream $out = _request ("clearAll", true);
01025                 $in = _invoke ($out);
01026                 return;
01027             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01028                 $in = $ex.getInputStream ();
01029                 String _id = $ex.getId ();
01030                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01031                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01032                 else
01033                     throw new org.omg.CORBA.MARSHAL (_id);
01034             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01035                 clearAll (        );
01036             } finally {
01037                 _releaseReply ($in);
01038             }
01039   } // clearAll
01040 
01041   public void namePartition (int partition, String name) throws sctConf.ConfigurationException
01042   {
01043             org.omg.CORBA.portable.InputStream $in = null;
01044             try {
01045                 org.omg.CORBA.portable.OutputStream $out = _request ("namePartition", true);
01046                 $out.write_ulong (partition);
01047                 $out.write_string (name);
01048                 $in = _invoke ($out);
01049                 return;
01050             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01051                 $in = $ex.getInputStream ();
01052                 String _id = $ex.getId ();
01053                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01054                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01055                 else
01056                     throw new org.omg.CORBA.MARSHAL (_id);
01057             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01058                 namePartition (partition, name        );
01059             } finally {
01060                 _releaseReply ($in);
01061             }
01062   } // namePartition
01063 
01064   public void mapRODMUR (int partition, int crate, int rod, int order, int number) throws sctConf.ConfigurationException
01065   {
01066             org.omg.CORBA.portable.InputStream $in = null;
01067             try {
01068                 org.omg.CORBA.portable.OutputStream $out = _request ("mapRODMUR", true);
01069                 $out.write_ulong (partition);
01070                 $out.write_ulong (crate);
01071                 $out.write_ulong (rod);
01072                 $out.write_ulong (order);
01073                 $out.write_ulong (number);
01074                 $in = _invoke ($out);
01075                 return;
01076             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01077                 $in = $ex.getInputStream ();
01078                 String _id = $ex.getId ();
01079                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01080                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01081                 else
01082                     throw new org.omg.CORBA.MARSHAL (_id);
01083             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01084                 mapRODMUR (partition, crate, rod, order, number        );
01085             } finally {
01086                 _releaseReply ($in);
01087             }
01088   } // mapRODMUR
01089 
01090   public void unmapRODMUR (int MUR) throws sctConf.ConfigurationException
01091   {
01092             org.omg.CORBA.portable.InputStream $in = null;
01093             try {
01094                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapRODMUR", true);
01095                 $out.write_ulong (MUR);
01096                 $in = _invoke ($out);
01097                 return;
01098             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01099                 $in = $ex.getInputStream ();
01100                 String _id = $ex.getId ();
01101                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01102                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01103                 else
01104                     throw new org.omg.CORBA.MARSHAL (_id);
01105             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01106                 unmapRODMUR (MUR        );
01107             } finally {
01108                 _releaseReply ($in);
01109             }
01110   } // unmapRODMUR
01111 
01112   public void mapBarrelMUR (int MUR, int barrel, int row, int position) throws sctConf.ConfigurationException
01113   {
01114             org.omg.CORBA.portable.InputStream $in = null;
01115             try {
01116                 org.omg.CORBA.portable.OutputStream $out = _request ("mapBarrelMUR", true);
01117                 $out.write_ulong (MUR);
01118                 $out.write_ulong (barrel);
01119                 $out.write_ulong (row);
01120                 $out.write_long (position);
01121                 $in = _invoke ($out);
01122                 return;
01123             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01124                 $in = $ex.getInputStream ();
01125                 String _id = $ex.getId ();
01126                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01127                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01128                 else
01129                     throw new org.omg.CORBA.MARSHAL (_id);
01130             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01131                 mapBarrelMUR (MUR, barrel, row, position        );
01132             } finally {
01133                 _releaseReply ($in);
01134             }
01135   } // mapBarrelMUR
01136 
01137   public void unmapBarrelMUR (int MUR) throws sctConf.ConfigurationException
01138   {
01139             org.omg.CORBA.portable.InputStream $in = null;
01140             try {
01141                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapBarrelMUR", true);
01142                 $out.write_ulong (MUR);
01143                 $in = _invoke ($out);
01144                 return;
01145             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01146                 $in = $ex.getInputStream ();
01147                 String _id = $ex.getId ();
01148                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01149                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01150                 else
01151                     throw new org.omg.CORBA.MARSHAL (_id);
01152             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01153                 unmapBarrelMUR (MUR        );
01154             } finally {
01155                 _releaseReply ($in);
01156             }
01157   } // unmapBarrelMUR
01158 
01159   public void mapEndcapMUR (int MUR, int disk, int quadrant, int position) throws sctConf.ConfigurationException
01160   {
01161             org.omg.CORBA.portable.InputStream $in = null;
01162             try {
01163                 org.omg.CORBA.portable.OutputStream $out = _request ("mapEndcapMUR", true);
01164                 $out.write_ulong (MUR);
01165                 $out.write_long (disk);
01166                 $out.write_ulong (quadrant);
01167                 $out.write_ulong (position);
01168                 $in = _invoke ($out);
01169                 return;
01170             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01171                 $in = $ex.getInputStream ();
01172                 String _id = $ex.getId ();
01173                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01174                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01175                 else
01176                     throw new org.omg.CORBA.MARSHAL (_id);
01177             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01178                 mapEndcapMUR (MUR, disk, quadrant, position        );
01179             } finally {
01180                 _releaseReply ($in);
01181             }
01182   } // mapEndcapMUR
01183 
01184   public void unmapEndcapMUR (int MUR) throws sctConf.ConfigurationException
01185   {
01186             org.omg.CORBA.portable.InputStream $in = null;
01187             try {
01188                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapEndcapMUR", true);
01189                 $out.write_ulong (MUR);
01190                 $in = _invoke ($out);
01191                 return;
01192             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01193                 $in = $ex.getInputStream ();
01194                 String _id = $ex.getId ();
01195                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01196                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01197                 else
01198                     throw new org.omg.CORBA.MARSHAL (_id);
01199             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01200                 unmapEndcapMUR (MUR        );
01201             } finally {
01202                 _releaseReply ($in);
01203             }
01204   } // unmapEndcapMUR
01205 
01206   public void mapPowerChannel (int MUR, int number, int partition, int crate, int channel) throws sctConf.ConfigurationException
01207   {
01208             org.omg.CORBA.portable.InputStream $in = null;
01209             try {
01210                 org.omg.CORBA.portable.OutputStream $out = _request ("mapPowerChannel", true);
01211                 $out.write_ulong (MUR);
01212                 $out.write_ulong (number);
01213                 $out.write_ulong (partition);
01214                 $out.write_ulong (crate);
01215                 $out.write_ulong (channel);
01216                 $in = _invoke ($out);
01217                 return;
01218             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01219                 $in = $ex.getInputStream ();
01220                 String _id = $ex.getId ();
01221                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01222                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01223                 else
01224                     throw new org.omg.CORBA.MARSHAL (_id);
01225             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01226                 mapPowerChannel (MUR, number, partition, crate, channel        );
01227             } finally {
01228                 _releaseReply ($in);
01229             }
01230   } // mapPowerChannel
01231 
01232   public void unmapPowerChannel (int MUR, int number) throws sctConf.ConfigurationException
01233   {
01234             org.omg.CORBA.portable.InputStream $in = null;
01235             try {
01236                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapPowerChannel", true);
01237                 $out.write_ulong (MUR);
01238                 $out.write_ulong (number);
01239                 $in = _invoke ($out);
01240                 return;
01241             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01242                 $in = $ex.getInputStream ();
01243                 String _id = $ex.getId ();
01244                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01245                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01246                 else
01247                     throw new org.omg.CORBA.MARSHAL (_id);
01248             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01249                 unmapPowerChannel (MUR, number        );
01250             } finally {
01251                 _releaseReply ($in);
01252             }
01253   } // unmapPowerChannel
01254 
01255   public void mapModuleMUR (int MUR, int order, int RMUR, int rorder, String sn) throws sctConf.ConfigurationException
01256   {
01257             org.omg.CORBA.portable.InputStream $in = null;
01258             try {
01259                 org.omg.CORBA.portable.OutputStream $out = _request ("mapModuleMUR", true);
01260                 $out.write_ulong (MUR);
01261                 $out.write_ulong (order);
01262                 $out.write_ulong (RMUR);
01263                 $out.write_ulong (rorder);
01264                 $out.write_string (sn);
01265                 $in = _invoke ($out);
01266                 return;
01267             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01268                 $in = $ex.getInputStream ();
01269                 String _id = $ex.getId ();
01270                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01271                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01272                 else
01273                     throw new org.omg.CORBA.MARSHAL (_id);
01274             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01275                 mapModuleMUR (MUR, order, RMUR, rorder, sn        );
01276             } finally {
01277                 _releaseReply ($in);
01278             }
01279   } // mapModuleMUR
01280 
01281   public void unmapModuleMUR (int MUR, int order) throws sctConf.ConfigurationException
01282   {
01283             org.omg.CORBA.portable.InputStream $in = null;
01284             try {
01285                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapModuleMUR", true);
01286                 $out.write_ulong (MUR);
01287                 $out.write_ulong (order);
01288                 $in = _invoke ($out);
01289                 return;
01290             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01291                 $in = $ex.getInputStream ();
01292                 String _id = $ex.getId ();
01293                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01294                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01295                 else
01296                     throw new org.omg.CORBA.MARSHAL (_id);
01297             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01298                 unmapModuleMUR (MUR, order        );
01299             } finally {
01300                 _releaseReply ($in);
01301             }
01302   } // unmapModuleMUR
01303 
01304   public void getMapMURROD (int MUR, org.omg.CORBA.IntHolder partition, org.omg.CORBA.IntHolder crate, org.omg.CORBA.IntHolder rod, org.omg.CORBA.IntHolder order) throws sctConf.ConfigurationException
01305   {
01306             org.omg.CORBA.portable.InputStream $in = null;
01307             try {
01308                 org.omg.CORBA.portable.OutputStream $out = _request ("getMapMURROD", true);
01309                 $out.write_ulong (MUR);
01310                 $in = _invoke ($out);
01311                 partition.value = $in.read_ulong ();
01312                 crate.value = $in.read_ulong ();
01313                 rod.value = $in.read_ulong ();
01314                 order.value = $in.read_ulong ();
01315                 return;
01316             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01317                 $in = $ex.getInputStream ();
01318                 String _id = $ex.getId ();
01319                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01320                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01321                 else
01322                     throw new org.omg.CORBA.MARSHAL (_id);
01323             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01324                 getMapMURROD (MUR, partition, crate, rod, order        );
01325             } finally {
01326                 _releaseReply ($in);
01327             }
01328   } // getMapMURROD
01329 
01330   public void getMapRODMUR (int partition, int crate, int rod, int order, org.omg.CORBA.IntHolder MUR) throws sctConf.ConfigurationException
01331   {
01332             org.omg.CORBA.portable.InputStream $in = null;
01333             try {
01334                 org.omg.CORBA.portable.OutputStream $out = _request ("getMapRODMUR", true);
01335                 $out.write_ulong (partition);
01336                 $out.write_ulong (crate);
01337                 $out.write_ulong (rod);
01338                 $out.write_ulong (order);
01339                 $in = _invoke ($out);
01340                 MUR.value = $in.read_ulong ();
01341                 return;
01342             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01343                 $in = $ex.getInputStream ();
01344                 String _id = $ex.getId ();
01345                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01346                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01347                 else
01348                     throw new org.omg.CORBA.MARSHAL (_id);
01349             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01350                 getMapRODMUR (partition, crate, rod, order, MUR        );
01351             } finally {
01352                 _releaseReply ($in);
01353             }
01354   } // getMapRODMUR
01355 
01356   public sctConf.MURType getMapMURPhysical (int MUR, org.omg.CORBA.IntHolder plane, org.omg.CORBA.IntHolder section, org.omg.CORBA.IntHolder position) throws sctConf.ConfigurationException
01357   {
01358             org.omg.CORBA.portable.InputStream $in = null;
01359             try {
01360                 org.omg.CORBA.portable.OutputStream $out = _request ("getMapMURPhysical", true);
01361                 $out.write_ulong (MUR);
01362                 $in = _invoke ($out);
01363                 sctConf.MURType $result = sctConf.MURTypeHelper.read ($in);
01364                 plane.value = $in.read_ulong ();
01365                 section.value = $in.read_ulong ();
01366                 position.value = $in.read_ulong ();
01367                 return $result;
01368             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01369                 $in = $ex.getInputStream ();
01370                 String _id = $ex.getId ();
01371                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01372                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01373                 else
01374                     throw new org.omg.CORBA.MARSHAL (_id);
01375             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01376                 return getMapMURPhysical (MUR, plane, section, position        );
01377             } finally {
01378                 _releaseReply ($in);
01379             }
01380   } // getMapMURPhysical
01381 
01382   public void swapMURNames (int MUR1, int MUR2) throws sctConf.ConfigurationException
01383   {
01384             org.omg.CORBA.portable.InputStream $in = null;
01385             try {
01386                 org.omg.CORBA.portable.OutputStream $out = _request ("swapMURNames", true);
01387                 $out.write_ulong (MUR1);
01388                 $out.write_ulong (MUR2);
01389                 $in = _invoke ($out);
01390                 return;
01391             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01392                 $in = $ex.getInputStream ();
01393                 String _id = $ex.getId ();
01394                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01395                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01396                 else
01397                     throw new org.omg.CORBA.MARSHAL (_id);
01398             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01399                 swapMURNames (MUR1, MUR2        );
01400             } finally {
01401                 _releaseReply ($in);
01402             }
01403   } // swapMURNames
01404 
01405   public void modifyDefaultPowerParam (String state, String name, String type, float value) throws sctConf.ConfigurationException
01406   {
01407             org.omg.CORBA.portable.InputStream $in = null;
01408             try {
01409                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyDefaultPowerParam", true);
01410                 $out.write_string (state);
01411                 $out.write_string (name);
01412                 $out.write_string (type);
01413                 $out.write_float (value);
01414                 $in = _invoke ($out);
01415                 return;
01416             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01417                 $in = $ex.getInputStream ();
01418                 String _id = $ex.getId ();
01419                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01420                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01421                 else
01422                     throw new org.omg.CORBA.MARSHAL (_id);
01423             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01424                 modifyDefaultPowerParam (state, name, type, value        );
01425             } finally {
01426                 _releaseReply ($in);
01427             }
01428   } // modifyDefaultPowerParam
01429 
01430   public void modifyHVCardParam (int crate, int card, String name, String type, float value) throws sctConf.ConfigurationException
01431   {
01432             org.omg.CORBA.portable.InputStream $in = null;
01433             try {
01434                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyHVCardParam", true);
01435                 $out.write_ulong (crate);
01436                 $out.write_ulong (card);
01437                 $out.write_string (name);
01438                 $out.write_string (type);
01439                 $out.write_float (value);
01440                 $in = _invoke ($out);
01441                 return;
01442             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01443                 $in = $ex.getInputStream ();
01444                 String _id = $ex.getId ();
01445                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01446                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01447                 else
01448                     throw new org.omg.CORBA.MARSHAL (_id);
01449             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01450                 modifyHVCardParam (crate, card, name, type, value        );
01451             } finally {
01452                 _releaseReply ($in);
01453             }
01454   } // modifyHVCardParam
01455 
01456   public void modifyLVCardParam (int crate, int card, String name, String type, float value) throws sctConf.ConfigurationException
01457   {
01458             org.omg.CORBA.portable.InputStream $in = null;
01459             try {
01460                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyLVCardParam", true);
01461                 $out.write_ulong (crate);
01462                 $out.write_ulong (card);
01463                 $out.write_string (name);
01464                 $out.write_string (type);
01465                 $out.write_float (value);
01466                 $in = _invoke ($out);
01467                 return;
01468             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01469                 $in = $ex.getInputStream ();
01470                 String _id = $ex.getId ();
01471                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01472                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01473                 else
01474                     throw new org.omg.CORBA.MARSHAL (_id);
01475             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01476                 modifyLVCardParam (crate, card, name, type, value        );
01477             } finally {
01478                 _releaseReply ($in);
01479             }
01480   } // modifyLVCardParam
01481 
01482   public void modifyPowerParam (int MUR, int number, String state, String name, String type, float value) throws sctConf.ConfigurationException
01483   {
01484             org.omg.CORBA.portable.InputStream $in = null;
01485             try {
01486                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyPowerParam", true);
01487                 $out.write_ulong (MUR);
01488                 $out.write_ulong (number);
01489                 $out.write_string (state);
01490                 $out.write_string (name);
01491                 $out.write_string (type);
01492                 $out.write_float (value);
01493                 $in = _invoke ($out);
01494                 return;
01495             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01496                 $in = $ex.getInputStream ();
01497                 String _id = $ex.getId ();
01498                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01499                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01500                 else
01501                     throw new org.omg.CORBA.MARSHAL (_id);
01502             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01503                 modifyPowerParam (MUR, number, state, name, type, value        );
01504             } finally {
01505                 _releaseReply ($in);
01506             }
01507   } // modifyPowerParam
01508 
01509   public void modifyPowerParamCC (int crate, int channel, String state, String name, String type, float value) throws sctConf.ConfigurationException
01510   {
01511             org.omg.CORBA.portable.InputStream $in = null;
01512             try {
01513                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyPowerParamCC", true);
01514                 $out.write_ulong (crate);
01515                 $out.write_ulong (channel);
01516                 $out.write_string (state);
01517                 $out.write_string (name);
01518                 $out.write_string (type);
01519                 $out.write_float (value);
01520                 $in = _invoke ($out);
01521                 return;
01522             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01523                 $in = $ex.getInputStream ();
01524                 String _id = $ex.getId ();
01525                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01526                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01527                 else
01528                     throw new org.omg.CORBA.MARSHAL (_id);
01529             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01530                 modifyPowerParamCC (crate, channel, state, name, type, value        );
01531             } finally {
01532                 _releaseReply ($in);
01533             }
01534   } // modifyPowerParamCC
01535 
01536   public float getDefaultPowerParam (String state, String name, String type) throws sctConf.ConfigurationException
01537   {
01538             org.omg.CORBA.portable.InputStream $in = null;
01539             try {
01540                 org.omg.CORBA.portable.OutputStream $out = _request ("getDefaultPowerParam", true);
01541                 $out.write_string (state);
01542                 $out.write_string (name);
01543                 $out.write_string (type);
01544                 $in = _invoke ($out);
01545                 float $result = $in.read_float ();
01546                 return $result;
01547             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01548                 $in = $ex.getInputStream ();
01549                 String _id = $ex.getId ();
01550                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01551                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01552                 else
01553                     throw new org.omg.CORBA.MARSHAL (_id);
01554             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01555                 return getDefaultPowerParam (state, name, type        );
01556             } finally {
01557                 _releaseReply ($in);
01558             }
01559   } // getDefaultPowerParam
01560 
01561   public float getHVCardParam (int crate, int card, String name, String type) throws sctConf.ConfigurationException
01562   {
01563             org.omg.CORBA.portable.InputStream $in = null;
01564             try {
01565                 org.omg.CORBA.portable.OutputStream $out = _request ("getHVCardParam", true);
01566                 $out.write_ulong (crate);
01567                 $out.write_ulong (card);
01568                 $out.write_string (name);
01569                 $out.write_string (type);
01570                 $in = _invoke ($out);
01571                 float $result = $in.read_float ();
01572                 return $result;
01573             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01574                 $in = $ex.getInputStream ();
01575                 String _id = $ex.getId ();
01576                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01577                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01578                 else
01579                     throw new org.omg.CORBA.MARSHAL (_id);
01580             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01581                 return getHVCardParam (crate, card, name, type        );
01582             } finally {
01583                 _releaseReply ($in);
01584             }
01585   } // getHVCardParam
01586 
01587 
01594   public float getLVCardParam (int crate, int card, String name, String type) throws sctConf.ConfigurationException
01595   {
01596             org.omg.CORBA.portable.InputStream $in = null;
01597             try {
01598                 org.omg.CORBA.portable.OutputStream $out = _request ("getLVCardParam", true);
01599                 $out.write_ulong (crate);
01600                 $out.write_ulong (card);
01601                 $out.write_string (name);
01602                 $out.write_string (type);
01603                 $in = _invoke ($out);
01604                 float $result = $in.read_float ();
01605                 return $result;
01606             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01607                 $in = $ex.getInputStream ();
01608                 String _id = $ex.getId ();
01609                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01610                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01611                 else
01612                     throw new org.omg.CORBA.MARSHAL (_id);
01613             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01614                 return getLVCardParam (crate, card, name, type        );
01615             } finally {
01616                 _releaseReply ($in);
01617             }
01618   } // getLVCardParam
01619 
01620 
01628   public float getPowerParam (int MUR, int number, String state, String name, String type) throws sctConf.ConfigurationException
01629   {
01630             org.omg.CORBA.portable.InputStream $in = null;
01631             try {
01632                 org.omg.CORBA.portable.OutputStream $out = _request ("getPowerParam", true);
01633                 $out.write_ulong (MUR);
01634                 $out.write_ulong (number);
01635                 $out.write_string (state);
01636                 $out.write_string (name);
01637                 $out.write_string (type);
01638                 $in = _invoke ($out);
01639                 float $result = $in.read_float ();
01640                 return $result;
01641             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01642                 $in = $ex.getInputStream ();
01643                 String _id = $ex.getId ();
01644                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01645                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01646                 else
01647                     throw new org.omg.CORBA.MARSHAL (_id);
01648             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01649                 return getPowerParam (MUR, number, state, name, type        );
01650             } finally {
01651                 _releaseReply ($in);
01652             }
01653   } // getPowerParam
01654 
01655 
01663   public float getPowerParamCC (int crate, int channel, String state, String name, String type) throws sctConf.ConfigurationException
01664   {
01665             org.omg.CORBA.portable.InputStream $in = null;
01666             try {
01667                 org.omg.CORBA.portable.OutputStream $out = _request ("getPowerParamCC", true);
01668                 $out.write_ulong (crate);
01669                 $out.write_ulong (channel);
01670                 $out.write_string (state);
01671                 $out.write_string (name);
01672                 $out.write_string (type);
01673                 $in = _invoke ($out);
01674                 float $result = $in.read_float ();
01675                 return $result;
01676             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01677                 $in = $ex.getInputStream ();
01678                 String _id = $ex.getId ();
01679                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01680                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01681                 else
01682                     throw new org.omg.CORBA.MARSHAL (_id);
01683             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01684                 return getPowerParamCC (crate, channel, state, name, type        );
01685             } finally {
01686                 _releaseReply ($in);
01687             }
01688   } // getPowerParamCC
01689 
01690   public String[] listDefaultPowerParams () throws sctConf.ConfigurationException
01691   {
01692             org.omg.CORBA.portable.InputStream $in = null;
01693             try {
01694                 org.omg.CORBA.portable.OutputStream $out = _request ("listDefaultPowerParams", true);
01695                 $in = _invoke ($out);
01696                 String $result[] = sctConf.NameListHelper.read ($in);
01697                 return $result;
01698             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01699                 $in = $ex.getInputStream ();
01700                 String _id = $ex.getId ();
01701                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01702                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01703                 else
01704                     throw new org.omg.CORBA.MARSHAL (_id);
01705             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01706                 return listDefaultPowerParams (        );
01707             } finally {
01708                 _releaseReply ($in);
01709             }
01710   } // listDefaultPowerParams
01711 
01712   public String[] listDCSChannelParams () throws sctConf.ConfigurationException
01713   {
01714             org.omg.CORBA.portable.InputStream $in = null;
01715             try {
01716                 org.omg.CORBA.portable.OutputStream $out = _request ("listDCSChannelParams", true);
01717                 $in = _invoke ($out);
01718                 String $result[] = sctConf.NameListHelper.read ($in);
01719                 return $result;
01720             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01721                 $in = $ex.getInputStream ();
01722                 String _id = $ex.getId ();
01723                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01724                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01725                 else
01726                     throw new org.omg.CORBA.MARSHAL (_id);
01727             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01728                 return listDCSChannelParams (        );
01729             } finally {
01730                 _releaseReply ($in);
01731             }
01732   } // listDCSChannelParams
01733 
01734   public String[] listDCSCardParams () throws sctConf.ConfigurationException
01735   {
01736             org.omg.CORBA.portable.InputStream $in = null;
01737             try {
01738                 org.omg.CORBA.portable.OutputStream $out = _request ("listDCSCardParams", true);
01739                 $in = _invoke ($out);
01740                 String $result[] = sctConf.NameListHelper.read ($in);
01741                 return $result;
01742             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01743                 $in = $ex.getInputStream ();
01744                 String _id = $ex.getId ();
01745                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01746                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01747                 else
01748                     throw new org.omg.CORBA.MARSHAL (_id);
01749             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01750                 return listDCSCardParams (        );
01751             } finally {
01752                 _releaseReply ($in);
01753             }
01754   } // listDCSCardParams
01755 
01756   public String[] listDCSCrateParams () throws sctConf.ConfigurationException
01757   {
01758             org.omg.CORBA.portable.InputStream $in = null;
01759             try {
01760                 org.omg.CORBA.portable.OutputStream $out = _request ("listDCSCrateParams", true);
01761                 $in = _invoke ($out);
01762                 String $result[] = sctConf.NameListHelper.read ($in);
01763                 return $result;
01764             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01765                 $in = $ex.getInputStream ();
01766                 String _id = $ex.getId ();
01767                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01768                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01769                 else
01770                     throw new org.omg.CORBA.MARSHAL (_id);
01771             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01772                 return listDCSCrateParams (        );
01773             } finally {
01774                 _releaseReply ($in);
01775             }
01776   } // listDCSCrateParams
01777 
01778   public void configureBOCChannel (int MUR, int position, sctConf.BOCChannelConfig conf) throws sctConf.ConfigurationException
01779   {
01780             org.omg.CORBA.portable.InputStream $in = null;
01781             try {
01782                 org.omg.CORBA.portable.OutputStream $out = _request ("configureBOCChannel", true);
01783                 $out.write_ulong (MUR);
01784                 $out.write_ulong (position);
01785                 sctConf.BOCChannelConfigHelper.write ($out, conf);
01786                 $in = _invoke ($out);
01787                 return;
01788             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01789                 $in = $ex.getInputStream ();
01790                 String _id = $ex.getId ();
01791                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01792                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01793                 else
01794                     throw new org.omg.CORBA.MARSHAL (_id);
01795             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01796                 configureBOCChannel (MUR, position, conf        );
01797             } finally {
01798                 _releaseReply ($in);
01799             }
01800   } // configureBOCChannel
01801 
01802   public void loadConfiguration (String filename) throws sctConf.ConfigurationException
01803   {
01804             org.omg.CORBA.portable.InputStream $in = null;
01805             try {
01806                 org.omg.CORBA.portable.OutputStream $out = _request ("loadConfiguration", true);
01807                 $out.write_string (filename);
01808                 $in = _invoke ($out);
01809                 return;
01810             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01811                 $in = $ex.getInputStream ();
01812                 String _id = $ex.getId ();
01813                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01814                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01815                 else
01816                     throw new org.omg.CORBA.MARSHAL (_id);
01817             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01818                 loadConfiguration (filename        );
01819             } finally {
01820                 _releaseReply ($in);
01821             }
01822   } // loadConfiguration
01823 
01824   public void saveConfiguration (String filename) throws sctConf.ConfigurationException
01825   {
01826             org.omg.CORBA.portable.InputStream $in = null;
01827             try {
01828                 org.omg.CORBA.portable.OutputStream $out = _request ("saveConfiguration", true);
01829                 $out.write_string (filename);
01830                 $in = _invoke ($out);
01831                 return;
01832             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01833                 $in = $ex.getInputStream ();
01834                 String _id = $ex.getId ();
01835                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01836                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01837                 else
01838                     throw new org.omg.CORBA.MARSHAL (_id);
01839             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01840                 saveConfiguration (filename        );
01841             } finally {
01842                 _releaseReply ($in);
01843             }
01844   } // saveConfiguration
01845 
01846   public void saveModuleConfiguration (String sn, String filename) throws sctConf.ConfigurationException
01847   {
01848             org.omg.CORBA.portable.InputStream $in = null;
01849             try {
01850                 org.omg.CORBA.portable.OutputStream $out = _request ("saveModuleConfiguration", true);
01851                 $out.write_string (sn);
01852                 $out.write_string (filename);
01853                 $in = _invoke ($out);
01854                 return;
01855             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01856                 $in = $ex.getInputStream ();
01857                 String _id = $ex.getId ();
01858                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01859                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01860                 else
01861                     throw new org.omg.CORBA.MARSHAL (_id);
01862             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01863                 saveModuleConfiguration (sn, filename        );
01864             } finally {
01865                 _releaseReply ($in);
01866             }
01867   } // saveModuleConfiguration
01868 
01869   public String getModuleConfigurationString (String modsn, sctConf.ABCDModule config) throws sctConf.ConfigurationException
01870   {
01871             org.omg.CORBA.portable.InputStream $in = null;
01872             try {
01873                 org.omg.CORBA.portable.OutputStream $out = _request ("getModuleConfigurationString", true);
01874                 $out.write_string (modsn);
01875                 sctConf.ABCDModuleHelper.write ($out, config);
01876                 $in = _invoke ($out);
01877                 String $result = $in.read_string ();
01878                 return $result;
01879             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01880                 $in = $ex.getInputStream ();
01881                 String _id = $ex.getId ();
01882                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01883                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01884                 else
01885                     throw new org.omg.CORBA.MARSHAL (_id);
01886             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01887                 return getModuleConfigurationString (modsn, config        );
01888             } finally {
01889                 _releaseReply ($in);
01890             }
01891   } // getModuleConfigurationString
01892 
01893   public void writePowerSupplyConfiguration (String directory) throws sctConf.ConfigurationException
01894   {
01895             org.omg.CORBA.portable.InputStream $in = null;
01896             try {
01897                 org.omg.CORBA.portable.OutputStream $out = _request ("writePowerSupplyConfiguration", true);
01898                 $out.write_string (directory);
01899                 $in = _invoke ($out);
01900                 return;
01901             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01902                 $in = $ex.getInputStream ();
01903                 String _id = $ex.getId ();
01904                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01905                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01906                 else
01907                     throw new org.omg.CORBA.MARSHAL (_id);
01908             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01909                 writePowerSupplyConfiguration (directory        );
01910             } finally {
01911                 _releaseReply ($in);
01912             }
01913   } // writePowerSupplyConfiguration
01914 
01915   public ipc.servantPackage.info information ()
01916   {
01917             org.omg.CORBA.portable.InputStream $in = null;
01918             try {
01919                 org.omg.CORBA.portable.OutputStream $out = _request ("_get_information", true);
01920                 $in = _invoke ($out);
01921                 ipc.servantPackage.info $result = ipc.servantPackage.infoHelper.read ($in);
01922                 return $result;
01923             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01924                 $in = $ex.getInputStream ();
01925                 String _id = $ex.getId ();
01926                 throw new org.omg.CORBA.MARSHAL (_id);
01927             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01928                 return information (        );
01929             } finally {
01930                 _releaseReply ($in);
01931             }
01932   } // information
01933 
01934   public void shutdown ()
01935   {
01936             org.omg.CORBA.portable.InputStream $in = null;
01937             try {
01938                 org.omg.CORBA.portable.OutputStream $out = _request ("shutdown", true);
01939                 $in = _invoke ($out);
01940                 return;
01941             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01942                 $in = $ex.getInputStream ();
01943                 String _id = $ex.getId ();
01944                 throw new org.omg.CORBA.MARSHAL (_id);
01945             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01946                 shutdown (        );
01947             } finally {
01948                 _releaseReply ($in);
01949             }
01950   } // shutdown
01951 
01952   // Type-specific CORBA::Object operations
01953   private static String[] __ids = {
01954     "IDL:sctConf/Configuration:1.0", 
01955     "IDL:ipc/servant:1.0"};
01956 
01957   public String[] _ids ()
01958   {
01959     return (String[])__ids.clone ();
01960   }
01961 
01962   private void readObject (java.io.ObjectInputStream s) throws java.io.IOException
01963   {
01964      String str = s.readUTF ();
01965      String[] args = null;
01966      java.util.Properties props = null;
01967      org.omg.CORBA.Object obj = org.omg.CORBA.ORB.init (args, props).string_to_object (str);
01968      org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl) obj)._get_delegate ();
01969      _set_delegate (delegate);
01970   }
01971 
01972   private void writeObject (java.io.ObjectOutputStream s) throws java.io.IOException
01973   {
01974      String[] args = null;
01975      java.util.Properties props = null;
01976      String str = org.omg.CORBA.ORB.init (args, props).object_to_string (this);
01977      s.writeUTF (str);
01978   }
01979 } // class _ConfigurationStub

Generated on Thu Feb 3 17:42:15 2005 for SCT DAQ/DCS Software - Java by doxygen 1.3.5