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 int getModuleErrorMask (int partition, int crate, int rod, int channel, short link) throws sctConf.ConfigurationException
00293   {
00294             org.omg.CORBA.portable.InputStream $in = null;
00295             try {
00296                 org.omg.CORBA.portable.OutputStream $out = _request ("getModuleErrorMask", true);
00297                 $out.write_ulong (partition);
00298                 $out.write_ulong (crate);
00299                 $out.write_ulong (rod);
00300                 $out.write_ulong (channel);
00301                 $out.write_ushort (link);
00302                 $in = _invoke ($out);
00303                 int $result = $in.read_ulong ();
00304                 return $result;
00305             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00306                 $in = $ex.getInputStream ();
00307                 String _id = $ex.getId ();
00308                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00309                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00310                 else
00311                     throw new org.omg.CORBA.MARSHAL (_id);
00312             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00313                 return getModuleErrorMask (partition, crate, rod, channel, link        );
00314             } finally {
00315                 _releaseReply ($in);
00316             }
00317   } // getModuleErrorMask
00318 
00319   public void setModuleErrorMask (int partition, int crate, int rod, int channel, short link, int mask) throws sctConf.ConfigurationException
00320   {
00321             org.omg.CORBA.portable.InputStream $in = null;
00322             try {
00323                 org.omg.CORBA.portable.OutputStream $out = _request ("setModuleErrorMask", true);
00324                 $out.write_ulong (partition);
00325                 $out.write_ulong (crate);
00326                 $out.write_ulong (rod);
00327                 $out.write_ulong (channel);
00328                 $out.write_ushort (link);
00329                 $out.write_ulong (mask);
00330                 $in = _invoke ($out);
00331                 return;
00332             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00333                 $in = $ex.getInputStream ();
00334                 String _id = $ex.getId ();
00335                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00336                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00337                 else
00338                     throw new org.omg.CORBA.MARSHAL (_id);
00339             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00340                 setModuleErrorMask (partition, crate, rod, channel, link, mask        );
00341             } finally {
00342                 _releaseReply ($in);
00343             }
00344   } // setModuleErrorMask
00345 
00346   public void setDefaultModuleErrorMask (int mask) throws sctConf.ConfigurationException
00347   {
00348             org.omg.CORBA.portable.InputStream $in = null;
00349             try {
00350                 org.omg.CORBA.portable.OutputStream $out = _request ("setDefaultModuleErrorMask", true);
00351                 $out.write_ulong (mask);
00352                 $in = _invoke ($out);
00353                 return;
00354             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00355                 $in = $ex.getInputStream ();
00356                 String _id = $ex.getId ();
00357                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00358                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00359                 else
00360                     throw new org.omg.CORBA.MARSHAL (_id);
00361             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00362                 setDefaultModuleErrorMask (mask        );
00363             } finally {
00364                 _releaseReply ($in);
00365             }
00366   } // setDefaultModuleErrorMask
00367 
00368   public sctConf.RodConfig getRodConfig (int partition, int crate, int rod) throws sctConf.ConfigurationException
00369   {
00370             org.omg.CORBA.portable.InputStream $in = null;
00371             try {
00372                 org.omg.CORBA.portable.OutputStream $out = _request ("getRodConfig", true);
00373                 $out.write_ulong (partition);
00374                 $out.write_ulong (crate);
00375                 $out.write_ulong (rod);
00376                 $in = _invoke ($out);
00377                 sctConf.RodConfig $result = sctConf.RodConfigHelper.read ($in);
00378                 return $result;
00379             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00380                 $in = $ex.getInputStream ();
00381                 String _id = $ex.getId ();
00382                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00383                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00384                 else
00385                     throw new org.omg.CORBA.MARSHAL (_id);
00386             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00387                 return getRodConfig (partition, crate, rod        );
00388             } finally {
00389                 _releaseReply ($in);
00390             }
00391   } // getRodConfig
00392 
00393   public sctConf.SlaveConfig getDefaultSlaveConfig (byte type) throws sctConf.ConfigurationException
00394   {
00395             org.omg.CORBA.portable.InputStream $in = null;
00396             try {
00397                 org.omg.CORBA.portable.OutputStream $out = _request ("getDefaultSlaveConfig", true);
00398                 $out.write_octet (type);
00399                 $in = _invoke ($out);
00400                 sctConf.SlaveConfig $result = sctConf.SlaveConfigHelper.read ($in);
00401                 return $result;
00402             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00403                 $in = $ex.getInputStream ();
00404                 String _id = $ex.getId ();
00405                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00406                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00407                 else
00408                     throw new org.omg.CORBA.MARSHAL (_id);
00409             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00410                 return getDefaultSlaveConfig (type        );
00411             } finally {
00412                 _releaseReply ($in);
00413             }
00414   } // getDefaultSlaveConfig
00415 
00416   public sctConf.TimConfig getTimConfig (int partition, int crate) throws sctConf.ConfigurationException
00417   {
00418             org.omg.CORBA.portable.InputStream $in = null;
00419             try {
00420                 org.omg.CORBA.portable.OutputStream $out = _request ("getTimConfig", true);
00421                 $out.write_ulong (partition);
00422                 $out.write_ulong (crate);
00423                 $in = _invoke ($out);
00424                 sctConf.TimConfig $result = sctConf.TimConfigHelper.read ($in);
00425                 return $result;
00426             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00427                 $in = $ex.getInputStream ();
00428                 String _id = $ex.getId ();
00429                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00430                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00431                 else
00432                     throw new org.omg.CORBA.MARSHAL (_id);
00433             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00434                 return getTimConfig (partition, crate        );
00435             } finally {
00436                 _releaseReply ($in);
00437             }
00438   } // getTimConfig
00439 
00440 
00441   // These should be unsigned (for comparison with 255)
00442   public byte[] getFibreMappings (int partition, int crate, int rod) throws sctConf.ConfigurationException
00443   {
00444             org.omg.CORBA.portable.InputStream $in = null;
00445             try {
00446                 org.omg.CORBA.portable.OutputStream $out = _request ("getFibreMappings", true);
00447                 $out.write_ulong (partition);
00448                 $out.write_ulong (crate);
00449                 $out.write_ulong (rod);
00450                 $in = _invoke ($out);
00451                 byte $result[] = sctConf.CharBlockHelper.read ($in);
00452                 return $result;
00453             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00454                 $in = $ex.getInputStream ();
00455                 String _id = $ex.getId ();
00456                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00457                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00458                 else
00459                     throw new org.omg.CORBA.MARSHAL (_id);
00460             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00461                 return getFibreMappings (partition, crate, rod        );
00462             } finally {
00463                 _releaseReply ($in);
00464             }
00465   } // getFibreMappings
00466 
00467   public void setFibreMapping (int partition, int crate, int rod, int channel, int tx, int rx0, int rx1) throws sctConf.ConfigurationException
00468   {
00469             org.omg.CORBA.portable.InputStream $in = null;
00470             try {
00471                 org.omg.CORBA.portable.OutputStream $out = _request ("setFibreMapping", true);
00472                 $out.write_ulong (partition);
00473                 $out.write_ulong (crate);
00474                 $out.write_ulong (rod);
00475                 $out.write_ulong (channel);
00476                 $out.write_ulong (tx);
00477                 $out.write_ulong (rx0);
00478                 $out.write_ulong (rx1);
00479                 $in = _invoke ($out);
00480                 return;
00481             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00482                 $in = $ex.getInputStream ();
00483                 String _id = $ex.getId ();
00484                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00485                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00486                 else
00487                     throw new org.omg.CORBA.MARSHAL (_id);
00488             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00489                 setFibreMapping (partition, crate, rod, channel, tx, rx0, rx1        );
00490             } finally {
00491                 _releaseReply ($in);
00492             }
00493   } // setFibreMapping
00494 
00495   public sctConf.BOCChannelConfig getBOCConfig (int partition, int crate, int rod, int channel) throws sctConf.ConfigurationException
00496   {
00497             org.omg.CORBA.portable.InputStream $in = null;
00498             try {
00499                 org.omg.CORBA.portable.OutputStream $out = _request ("getBOCConfig", true);
00500                 $out.write_ulong (partition);
00501                 $out.write_ulong (crate);
00502                 $out.write_ulong (rod);
00503                 $out.write_ulong (channel);
00504                 $in = _invoke ($out);
00505                 sctConf.BOCChannelConfig $result = sctConf.BOCChannelConfigHelper.read ($in);
00506                 return $result;
00507             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00508                 $in = $ex.getInputStream ();
00509                 String _id = $ex.getId ();
00510                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00511                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00512                 else
00513                     throw new org.omg.CORBA.MARSHAL (_id);
00514             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00515                 return getBOCConfig (partition, crate, rod, channel        );
00516             } finally {
00517                 _releaseReply ($in);
00518             }
00519   } // getBOCConfig
00520 
00521   public sctConf.BOCGlobalConfig getBOCGlobalConfig (int partition, int crate, int rod) throws sctConf.ConfigurationException
00522   {
00523             org.omg.CORBA.portable.InputStream $in = null;
00524             try {
00525                 org.omg.CORBA.portable.OutputStream $out = _request ("getBOCGlobalConfig", true);
00526                 $out.write_ulong (partition);
00527                 $out.write_ulong (crate);
00528                 $out.write_ulong (rod);
00529                 $in = _invoke ($out);
00530                 sctConf.BOCGlobalConfig $result = sctConf.BOCGlobalConfigHelper.read ($in);
00531                 return $result;
00532             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00533                 $in = $ex.getInputStream ();
00534                 String _id = $ex.getId ();
00535                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00536                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00537                 else
00538                     throw new org.omg.CORBA.MARSHAL (_id);
00539             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00540                 return getBOCGlobalConfig (partition, crate, rod        );
00541             } finally {
00542                 _releaseReply ($in);
00543             }
00544   } // getBOCGlobalConfig
00545 
00546   public void printModuleConfig (sctConf.ABCDModule conf) throws sctConf.ConfigurationException
00547   {
00548             org.omg.CORBA.portable.InputStream $in = null;
00549             try {
00550                 org.omg.CORBA.portable.OutputStream $out = _request ("printModuleConfig", true);
00551                 sctConf.ABCDModuleHelper.write ($out, conf);
00552                 $in = _invoke ($out);
00553                 return;
00554             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00555                 $in = $ex.getInputStream ();
00556                 String _id = $ex.getId ();
00557                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00558                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00559                 else
00560                     throw new org.omg.CORBA.MARSHAL (_id);
00561             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00562                 printModuleConfig (conf        );
00563             } finally {
00564                 _releaseReply ($in);
00565             }
00566   } // printModuleConfig
00567 
00568   public sctConf.MURType getMURType (int MUR) throws sctConf.ConfigurationException
00569   {
00570             org.omg.CORBA.portable.InputStream $in = null;
00571             try {
00572                 org.omg.CORBA.portable.OutputStream $out = _request ("getMURType", true);
00573                 $out.write_ulong (MUR);
00574                 $in = _invoke ($out);
00575                 sctConf.MURType $result = sctConf.MURTypeHelper.read ($in);
00576                 return $result;
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                 return getMURType (MUR        );
00586             } finally {
00587                 _releaseReply ($in);
00588             }
00589   } // getMURType
00590 
00591   public int getFreeMurId () throws sctConf.ConfigurationException
00592   {
00593             org.omg.CORBA.portable.InputStream $in = null;
00594             try {
00595                 org.omg.CORBA.portable.OutputStream $out = _request ("getFreeMurId", true);
00596                 $in = _invoke ($out);
00597                 int $result = $in.read_ulong ();
00598                 return $result;
00599             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00600                 $in = $ex.getInputStream ();
00601                 String _id = $ex.getId ();
00602                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00603                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00604                 else
00605                     throw new org.omg.CORBA.MARSHAL (_id);
00606             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00607                 return getFreeMurId (        );
00608             } finally {
00609                 _releaseReply ($in);
00610             }
00611   } // getFreeMurId
00612 
00613   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
00614   {
00615             org.omg.CORBA.portable.InputStream $in = null;
00616             try {
00617                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToROD", true);
00618                 $out.write_ulong (MUR);
00619                 $out.write_ulong (mod);
00620                 $in = _invoke ($out);
00621                 partition.value = $in.read_ulong ();
00622                 crate.value = $in.read_ulong ();
00623                 rod.value = $in.read_ulong ();
00624                 channel.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                 translateToROD (MUR, mod, partition, crate, rod, channel        );
00635             } finally {
00636                 _releaseReply ($in);
00637             }
00638   } // translateToROD
00639 
00640   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
00641   {
00642             org.omg.CORBA.portable.InputStream $in = null;
00643             try {
00644                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToRROD", true);
00645                 $out.write_ulong (MUR);
00646                 $out.write_ulong (mod);
00647                 $in = _invoke ($out);
00648                 partition.value = $in.read_ulong ();
00649                 crate.value = $in.read_ulong ();
00650                 rod.value = $in.read_ulong ();
00651                 channel.value = $in.read_ulong ();
00652                 return;
00653             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00654                 $in = $ex.getInputStream ();
00655                 String _id = $ex.getId ();
00656                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00657                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00658                 else
00659                     throw new org.omg.CORBA.MARSHAL (_id);
00660             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00661                 translateToRROD (MUR, mod, partition, crate, rod, channel        );
00662             } finally {
00663                 _releaseReply ($in);
00664             }
00665   } // translateToRROD
00666 
00667   public void translateToSN (int MUR, int mod, org.omg.CORBA.StringHolder sn) throws sctConf.ConfigurationException
00668   {
00669             org.omg.CORBA.portable.InputStream $in = null;
00670             try {
00671                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToSN", true);
00672                 $out.write_ulong (MUR);
00673                 $out.write_ulong (mod);
00674                 $in = _invoke ($out);
00675                 sn.value = $in.read_string ();
00676                 return;
00677             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00678                 $in = $ex.getInputStream ();
00679                 String _id = $ex.getId ();
00680                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00681                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00682                 else
00683                     throw new org.omg.CORBA.MARSHAL (_id);
00684             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00685                 translateToSN (MUR, mod, sn        );
00686             } finally {
00687                 _releaseReply ($in);
00688             }
00689   } // translateToSN
00690 
00691   public void translateToRMUR (int RMUR, int rmod, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00692   {
00693             org.omg.CORBA.portable.InputStream $in = null;
00694             try {
00695                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToRMUR", true);
00696                 $out.write_ulong (RMUR);
00697                 $out.write_ulong (rmod);
00698                 $in = _invoke ($out);
00699                 MUR.value = $in.read_ulong ();
00700                 mod.value = $in.read_ulong ();
00701                 return;
00702             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00703                 $in = $ex.getInputStream ();
00704                 String _id = $ex.getId ();
00705                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00706                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00707                 else
00708                     throw new org.omg.CORBA.MARSHAL (_id);
00709             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00710                 translateToRMUR (RMUR, rmod, MUR, mod        );
00711             } finally {
00712                 _releaseReply ($in);
00713             }
00714   } // translateToRMUR
00715 
00716   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
00717   {
00718             org.omg.CORBA.portable.InputStream $in = null;
00719             try {
00720                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToBarrel", true);
00721                 $out.write_ulong (MUR);
00722                 $out.write_ulong (mod);
00723                 $in = _invoke ($out);
00724                 barrel.value = $in.read_ulong ();
00725                 row.value = $in.read_ulong ();
00726                 number.value = $in.read_long ();
00727                 return;
00728             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00729                 $in = $ex.getInputStream ();
00730                 String _id = $ex.getId ();
00731                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00732                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00733                 else
00734                     throw new org.omg.CORBA.MARSHAL (_id);
00735             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00736                 translateToBarrel (MUR, mod, barrel, row, number        );
00737             } finally {
00738                 _releaseReply ($in);
00739             }
00740   } // translateToBarrel
00741 
00742   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
00743   {
00744             org.omg.CORBA.portable.InputStream $in = null;
00745             try {
00746                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToEndcap", true);
00747                 $out.write_ulong (MUR);
00748                 $out.write_ulong (mod);
00749                 $in = _invoke ($out);
00750                 disk.value = $in.read_long ();
00751                 ring.value = $in.read_ulong ();
00752                 number.value = $in.read_ulong ();
00753                 return;
00754             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00755                 $in = $ex.getInputStream ();
00756                 String _id = $ex.getId ();
00757                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00758                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00759                 else
00760                     throw new org.omg.CORBA.MARSHAL (_id);
00761             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00762                 translateToEndcap (MUR, mod, disk, ring, number        );
00763             } finally {
00764                 _releaseReply ($in);
00765             }
00766   } // translateToEndcap
00767 
00768   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
00769   {
00770             org.omg.CORBA.portable.InputStream $in = null;
00771             try {
00772                 org.omg.CORBA.portable.OutputStream $out = _request ("translateToPowerSupply", true);
00773                 $out.write_ulong (MUR);
00774                 $out.write_ulong (mod);
00775                 $in = _invoke ($out);
00776                 partition.value = $in.read_ulong ();
00777                 crate.value = $in.read_ulong ();
00778                 channel.value = $in.read_ulong ();
00779                 return;
00780             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00781                 $in = $ex.getInputStream ();
00782                 String _id = $ex.getId ();
00783                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00784                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00785                 else
00786                     throw new org.omg.CORBA.MARSHAL (_id);
00787             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00788                 translateToPowerSupply (MUR, mod, partition, crate, channel        );
00789             } finally {
00790                 _releaseReply ($in);
00791             }
00792   } // translateToPowerSupply
00793 
00794   public void translateFromROD (int partition, int crate, int rod, int channel, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00795   {
00796             org.omg.CORBA.portable.InputStream $in = null;
00797             try {
00798                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromROD", true);
00799                 $out.write_ulong (partition);
00800                 $out.write_ulong (crate);
00801                 $out.write_ulong (rod);
00802                 $out.write_ulong (channel);
00803                 $in = _invoke ($out);
00804                 MUR.value = $in.read_ulong ();
00805                 mod.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                 translateFromROD (partition, crate, rod, channel, MUR, mod        );
00816             } finally {
00817                 _releaseReply ($in);
00818             }
00819   } // translateFromROD
00820 
00821   public void translateFromRROD (int partition, int crate, int rod, int channel, 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 ("translateFromRROD", true);
00826                 $out.write_ulong (partition);
00827                 $out.write_ulong (crate);
00828                 $out.write_ulong (rod);
00829                 $out.write_ulong (channel);
00830                 $in = _invoke ($out);
00831                 MUR.value = $in.read_ulong ();
00832                 mod.value = $in.read_ulong ();
00833                 return;
00834             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00835                 $in = $ex.getInputStream ();
00836                 String _id = $ex.getId ();
00837                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00838                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00839                 else
00840                     throw new org.omg.CORBA.MARSHAL (_id);
00841             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00842                 translateFromRROD (partition, crate, rod, channel, MUR, mod        );
00843             } finally {
00844                 _releaseReply ($in);
00845             }
00846   } // translateFromRROD
00847 
00848   public void translateFromSN (String sn, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00849   {
00850             org.omg.CORBA.portable.InputStream $in = null;
00851             try {
00852                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromSN", true);
00853                 $out.write_string (sn);
00854                 $in = _invoke ($out);
00855                 MUR.value = $in.read_ulong ();
00856                 mod.value = $in.read_ulong ();
00857                 return;
00858             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00859                 $in = $ex.getInputStream ();
00860                 String _id = $ex.getId ();
00861                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00862                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00863                 else
00864                     throw new org.omg.CORBA.MARSHAL (_id);
00865             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00866                 translateFromSN (sn, MUR, mod        );
00867             } finally {
00868                 _releaseReply ($in);
00869             }
00870   } // translateFromSN
00871 
00872   public void translateFromRMUR (int MUR, int mod, org.omg.CORBA.IntHolder RMUR, org.omg.CORBA.IntHolder rmod) throws sctConf.ConfigurationException
00873   {
00874             org.omg.CORBA.portable.InputStream $in = null;
00875             try {
00876                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromRMUR", true);
00877                 $out.write_ulong (MUR);
00878                 $out.write_ulong (mod);
00879                 $in = _invoke ($out);
00880                 RMUR.value = $in.read_ulong ();
00881                 rmod.value = $in.read_ulong ();
00882                 return;
00883             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00884                 $in = $ex.getInputStream ();
00885                 String _id = $ex.getId ();
00886                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00887                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00888                 else
00889                     throw new org.omg.CORBA.MARSHAL (_id);
00890             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00891                 translateFromRMUR (MUR, mod, RMUR, rmod        );
00892             } finally {
00893                 _releaseReply ($in);
00894             }
00895   } // translateFromRMUR
00896 
00897   public void translateFromBarrel (int barrel, int row, int number, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00898   {
00899             org.omg.CORBA.portable.InputStream $in = null;
00900             try {
00901                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromBarrel", true);
00902                 $out.write_ulong (barrel);
00903                 $out.write_ulong (row);
00904                 $out.write_long (number);
00905                 $in = _invoke ($out);
00906                 MUR.value = $in.read_ulong ();
00907                 mod.value = $in.read_ulong ();
00908                 return;
00909             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00910                 $in = $ex.getInputStream ();
00911                 String _id = $ex.getId ();
00912                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00913                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00914                 else
00915                     throw new org.omg.CORBA.MARSHAL (_id);
00916             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00917                 translateFromBarrel (barrel, row, number, MUR, mod        );
00918             } finally {
00919                 _releaseReply ($in);
00920             }
00921   } // translateFromBarrel
00922 
00923   public void translateFromEndcap (int disk, int ring, int number, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00924   {
00925             org.omg.CORBA.portable.InputStream $in = null;
00926             try {
00927                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromEndcap", true);
00928                 $out.write_long (disk);
00929                 $out.write_ulong (ring);
00930                 $out.write_ulong (number);
00931                 $in = _invoke ($out);
00932                 MUR.value = $in.read_ulong ();
00933                 mod.value = $in.read_ulong ();
00934                 return;
00935             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00936                 $in = $ex.getInputStream ();
00937                 String _id = $ex.getId ();
00938                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00939                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00940                 else
00941                     throw new org.omg.CORBA.MARSHAL (_id);
00942             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00943                 translateFromEndcap (disk, ring, number, MUR, mod        );
00944             } finally {
00945                 _releaseReply ($in);
00946             }
00947   } // translateFromEndcap
00948 
00949   public void translateFromPowerSupply (int partition, int crate, int channel, org.omg.CORBA.IntHolder MUR, org.omg.CORBA.IntHolder mod) throws sctConf.ConfigurationException
00950   {
00951             org.omg.CORBA.portable.InputStream $in = null;
00952             try {
00953                 org.omg.CORBA.portable.OutputStream $out = _request ("translateFromPowerSupply", true);
00954                 $out.write_ulong (partition);
00955                 $out.write_ulong (crate);
00956                 $out.write_ulong (channel);
00957                 $in = _invoke ($out);
00958                 MUR.value = $in.read_ulong ();
00959                 mod.value = $in.read_ulong ();
00960                 return;
00961             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00962                 $in = $ex.getInputStream ();
00963                 String _id = $ex.getId ();
00964                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00965                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00966                 else
00967                     throw new org.omg.CORBA.MARSHAL (_id);
00968             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00969                 translateFromPowerSupply (partition, crate, channel, MUR, mod        );
00970             } finally {
00971                 _releaseReply ($in);
00972             }
00973   } // translateFromPowerSupply
00974 
00975 
00976   //       raises(ConfigurationException);
00977   public void configureModuleFromStructure (String number, sctConf.ABCDModule mConf) throws sctConf.ConfigurationException
00978   {
00979             org.omg.CORBA.portable.InputStream $in = null;
00980             try {
00981                 org.omg.CORBA.portable.OutputStream $out = _request ("configureModuleFromStructure", true);
00982                 $out.write_string (number);
00983                 sctConf.ABCDModuleHelper.write ($out, mConf);
00984                 $in = _invoke ($out);
00985                 return;
00986             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
00987                 $in = $ex.getInputStream ();
00988                 String _id = $ex.getId ();
00989                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
00990                     throw sctConf.ConfigurationExceptionHelper.read ($in);
00991                 else
00992                     throw new org.omg.CORBA.MARSHAL (_id);
00993             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
00994                 configureModuleFromStructure (number, mConf        );
00995             } finally {
00996                 _releaseReply ($in);
00997             }
00998   } // configureModuleFromStructure
00999 
01000   public void configureModuleFromFile (String filename) throws sctConf.ConfigurationException
01001   {
01002             org.omg.CORBA.portable.InputStream $in = null;
01003             try {
01004                 org.omg.CORBA.portable.OutputStream $out = _request ("configureModuleFromFile", true);
01005                 $out.write_string (filename);
01006                 $in = _invoke ($out);
01007                 return;
01008             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01009                 $in = $ex.getInputStream ();
01010                 String _id = $ex.getId ();
01011                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01012                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01013                 else
01014                     throw new org.omg.CORBA.MARSHAL (_id);
01015             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01016                 configureModuleFromFile (filename        );
01017             } finally {
01018                 _releaseReply ($in);
01019             }
01020   } // configureModuleFromFile
01021 
01022   public void configureROD (int partition, int crate, int rod, sctConf.RodConfig conf) throws sctConf.ConfigurationException
01023   {
01024             org.omg.CORBA.portable.InputStream $in = null;
01025             try {
01026                 org.omg.CORBA.portable.OutputStream $out = _request ("configureROD", true);
01027                 $out.write_ulong (partition);
01028                 $out.write_ulong (crate);
01029                 $out.write_ulong (rod);
01030                 sctConf.RodConfigHelper.write ($out, conf);
01031                 $in = _invoke ($out);
01032                 return;
01033             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01034                 $in = $ex.getInputStream ();
01035                 String _id = $ex.getId ();
01036                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01037                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01038                 else
01039                     throw new org.omg.CORBA.MARSHAL (_id);
01040             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01041                 configureROD (partition, crate, rod, conf        );
01042             } finally {
01043                 _releaseReply ($in);
01044             }
01045   } // configureROD
01046 
01047   public void configureTIM (int partition, int crate, sctConf.TimConfig conf) throws sctConf.ConfigurationException
01048   {
01049             org.omg.CORBA.portable.InputStream $in = null;
01050             try {
01051                 org.omg.CORBA.portable.OutputStream $out = _request ("configureTIM", true);
01052                 $out.write_ulong (partition);
01053                 $out.write_ulong (crate);
01054                 sctConf.TimConfigHelper.write ($out, conf);
01055                 $in = _invoke ($out);
01056                 return;
01057             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01058                 $in = $ex.getInputStream ();
01059                 String _id = $ex.getId ();
01060                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01061                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01062                 else
01063                     throw new org.omg.CORBA.MARSHAL (_id);
01064             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01065                 configureTIM (partition, crate, conf        );
01066             } finally {
01067                 _releaseReply ($in);
01068             }
01069   } // configureTIM
01070 
01071   public void configureBOC (int partition, int crate, int rod, sctConf.BOCGlobalConfig conf) throws sctConf.ConfigurationException
01072   {
01073             org.omg.CORBA.portable.InputStream $in = null;
01074             try {
01075                 org.omg.CORBA.portable.OutputStream $out = _request ("configureBOC", true);
01076                 $out.write_ulong (partition);
01077                 $out.write_ulong (crate);
01078                 $out.write_ulong (rod);
01079                 sctConf.BOCGlobalConfigHelper.write ($out, conf);
01080                 $in = _invoke ($out);
01081                 return;
01082             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01083                 $in = $ex.getInputStream ();
01084                 String _id = $ex.getId ();
01085                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01086                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01087                 else
01088                     throw new org.omg.CORBA.MARSHAL (_id);
01089             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01090                 configureBOC (partition, crate, rod, conf        );
01091             } finally {
01092                 _releaseReply ($in);
01093             }
01094   } // configureBOC
01095 
01096   public void clearAll () throws sctConf.ConfigurationException
01097   {
01098             org.omg.CORBA.portable.InputStream $in = null;
01099             try {
01100                 org.omg.CORBA.portable.OutputStream $out = _request ("clearAll", true);
01101                 $in = _invoke ($out);
01102                 return;
01103             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01104                 $in = $ex.getInputStream ();
01105                 String _id = $ex.getId ();
01106                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01107                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01108                 else
01109                     throw new org.omg.CORBA.MARSHAL (_id);
01110             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01111                 clearAll (        );
01112             } finally {
01113                 _releaseReply ($in);
01114             }
01115   } // clearAll
01116 
01117   public void namePartition (int partition, String name) throws sctConf.ConfigurationException
01118   {
01119             org.omg.CORBA.portable.InputStream $in = null;
01120             try {
01121                 org.omg.CORBA.portable.OutputStream $out = _request ("namePartition", true);
01122                 $out.write_ulong (partition);
01123                 $out.write_string (name);
01124                 $in = _invoke ($out);
01125                 return;
01126             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01127                 $in = $ex.getInputStream ();
01128                 String _id = $ex.getId ();
01129                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01130                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01131                 else
01132                     throw new org.omg.CORBA.MARSHAL (_id);
01133             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01134                 namePartition (partition, name        );
01135             } finally {
01136                 _releaseReply ($in);
01137             }
01138   } // namePartition
01139 
01140   public void mapRODMUR (int partition, int crate, int rod, int order, int number) throws sctConf.ConfigurationException
01141   {
01142             org.omg.CORBA.portable.InputStream $in = null;
01143             try {
01144                 org.omg.CORBA.portable.OutputStream $out = _request ("mapRODMUR", true);
01145                 $out.write_ulong (partition);
01146                 $out.write_ulong (crate);
01147                 $out.write_ulong (rod);
01148                 $out.write_ulong (order);
01149                 $out.write_ulong (number);
01150                 $in = _invoke ($out);
01151                 return;
01152             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01153                 $in = $ex.getInputStream ();
01154                 String _id = $ex.getId ();
01155                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01156                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01157                 else
01158                     throw new org.omg.CORBA.MARSHAL (_id);
01159             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01160                 mapRODMUR (partition, crate, rod, order, number        );
01161             } finally {
01162                 _releaseReply ($in);
01163             }
01164   } // mapRODMUR
01165 
01166   public void unmapRODMUR (int MUR) throws sctConf.ConfigurationException
01167   {
01168             org.omg.CORBA.portable.InputStream $in = null;
01169             try {
01170                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapRODMUR", true);
01171                 $out.write_ulong (MUR);
01172                 $in = _invoke ($out);
01173                 return;
01174             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01175                 $in = $ex.getInputStream ();
01176                 String _id = $ex.getId ();
01177                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01178                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01179                 else
01180                     throw new org.omg.CORBA.MARSHAL (_id);
01181             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01182                 unmapRODMUR (MUR        );
01183             } finally {
01184                 _releaseReply ($in);
01185             }
01186   } // unmapRODMUR
01187 
01188   public void mapBarrelMUR (int MUR, int barrel, int row, int position) throws sctConf.ConfigurationException
01189   {
01190             org.omg.CORBA.portable.InputStream $in = null;
01191             try {
01192                 org.omg.CORBA.portable.OutputStream $out = _request ("mapBarrelMUR", true);
01193                 $out.write_ulong (MUR);
01194                 $out.write_ulong (barrel);
01195                 $out.write_ulong (row);
01196                 $out.write_long (position);
01197                 $in = _invoke ($out);
01198                 return;
01199             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01200                 $in = $ex.getInputStream ();
01201                 String _id = $ex.getId ();
01202                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01203                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01204                 else
01205                     throw new org.omg.CORBA.MARSHAL (_id);
01206             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01207                 mapBarrelMUR (MUR, barrel, row, position        );
01208             } finally {
01209                 _releaseReply ($in);
01210             }
01211   } // mapBarrelMUR
01212 
01213   public void unmapBarrelMUR (int MUR) throws sctConf.ConfigurationException
01214   {
01215             org.omg.CORBA.portable.InputStream $in = null;
01216             try {
01217                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapBarrelMUR", true);
01218                 $out.write_ulong (MUR);
01219                 $in = _invoke ($out);
01220                 return;
01221             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01222                 $in = $ex.getInputStream ();
01223                 String _id = $ex.getId ();
01224                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01225                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01226                 else
01227                     throw new org.omg.CORBA.MARSHAL (_id);
01228             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01229                 unmapBarrelMUR (MUR        );
01230             } finally {
01231                 _releaseReply ($in);
01232             }
01233   } // unmapBarrelMUR
01234 
01235   public void mapEndcapMUR (int MUR, int disk, int quadrant, int position) throws sctConf.ConfigurationException
01236   {
01237             org.omg.CORBA.portable.InputStream $in = null;
01238             try {
01239                 org.omg.CORBA.portable.OutputStream $out = _request ("mapEndcapMUR", true);
01240                 $out.write_ulong (MUR);
01241                 $out.write_long (disk);
01242                 $out.write_ulong (quadrant);
01243                 $out.write_ulong (position);
01244                 $in = _invoke ($out);
01245                 return;
01246             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01247                 $in = $ex.getInputStream ();
01248                 String _id = $ex.getId ();
01249                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01250                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01251                 else
01252                     throw new org.omg.CORBA.MARSHAL (_id);
01253             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01254                 mapEndcapMUR (MUR, disk, quadrant, position        );
01255             } finally {
01256                 _releaseReply ($in);
01257             }
01258   } // mapEndcapMUR
01259 
01260   public void unmapEndcapMUR (int MUR) throws sctConf.ConfigurationException
01261   {
01262             org.omg.CORBA.portable.InputStream $in = null;
01263             try {
01264                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapEndcapMUR", true);
01265                 $out.write_ulong (MUR);
01266                 $in = _invoke ($out);
01267                 return;
01268             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01269                 $in = $ex.getInputStream ();
01270                 String _id = $ex.getId ();
01271                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01272                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01273                 else
01274                     throw new org.omg.CORBA.MARSHAL (_id);
01275             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01276                 unmapEndcapMUR (MUR        );
01277             } finally {
01278                 _releaseReply ($in);
01279             }
01280   } // unmapEndcapMUR
01281 
01282   public void mapPowerChannel (int MUR, int number, int partition, int crate, int channel) throws sctConf.ConfigurationException
01283   {
01284             org.omg.CORBA.portable.InputStream $in = null;
01285             try {
01286                 org.omg.CORBA.portable.OutputStream $out = _request ("mapPowerChannel", true);
01287                 $out.write_ulong (MUR);
01288                 $out.write_ulong (number);
01289                 $out.write_ulong (partition);
01290                 $out.write_ulong (crate);
01291                 $out.write_ulong (channel);
01292                 $in = _invoke ($out);
01293                 return;
01294             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01295                 $in = $ex.getInputStream ();
01296                 String _id = $ex.getId ();
01297                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01298                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01299                 else
01300                     throw new org.omg.CORBA.MARSHAL (_id);
01301             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01302                 mapPowerChannel (MUR, number, partition, crate, channel        );
01303             } finally {
01304                 _releaseReply ($in);
01305             }
01306   } // mapPowerChannel
01307 
01308   public void unmapPowerChannel (int MUR, int number) throws sctConf.ConfigurationException
01309   {
01310             org.omg.CORBA.portable.InputStream $in = null;
01311             try {
01312                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapPowerChannel", true);
01313                 $out.write_ulong (MUR);
01314                 $out.write_ulong (number);
01315                 $in = _invoke ($out);
01316                 return;
01317             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01318                 $in = $ex.getInputStream ();
01319                 String _id = $ex.getId ();
01320                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01321                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01322                 else
01323                     throw new org.omg.CORBA.MARSHAL (_id);
01324             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01325                 unmapPowerChannel (MUR, number        );
01326             } finally {
01327                 _releaseReply ($in);
01328             }
01329   } // unmapPowerChannel
01330 
01331   public void mapModuleMUR (int MUR, int order, int RMUR, int rorder, String sn) throws sctConf.ConfigurationException
01332   {
01333             org.omg.CORBA.portable.InputStream $in = null;
01334             try {
01335                 org.omg.CORBA.portable.OutputStream $out = _request ("mapModuleMUR", true);
01336                 $out.write_ulong (MUR);
01337                 $out.write_ulong (order);
01338                 $out.write_ulong (RMUR);
01339                 $out.write_ulong (rorder);
01340                 $out.write_string (sn);
01341                 $in = _invoke ($out);
01342                 return;
01343             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01344                 $in = $ex.getInputStream ();
01345                 String _id = $ex.getId ();
01346                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01347                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01348                 else
01349                     throw new org.omg.CORBA.MARSHAL (_id);
01350             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01351                 mapModuleMUR (MUR, order, RMUR, rorder, sn        );
01352             } finally {
01353                 _releaseReply ($in);
01354             }
01355   } // mapModuleMUR
01356 
01357   public void unmapModuleMUR (int MUR, int order) throws sctConf.ConfigurationException
01358   {
01359             org.omg.CORBA.portable.InputStream $in = null;
01360             try {
01361                 org.omg.CORBA.portable.OutputStream $out = _request ("unmapModuleMUR", true);
01362                 $out.write_ulong (MUR);
01363                 $out.write_ulong (order);
01364                 $in = _invoke ($out);
01365                 return;
01366             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01367                 $in = $ex.getInputStream ();
01368                 String _id = $ex.getId ();
01369                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01370                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01371                 else
01372                     throw new org.omg.CORBA.MARSHAL (_id);
01373             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01374                 unmapModuleMUR (MUR, order        );
01375             } finally {
01376                 _releaseReply ($in);
01377             }
01378   } // unmapModuleMUR
01379 
01380   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
01381   {
01382             org.omg.CORBA.portable.InputStream $in = null;
01383             try {
01384                 org.omg.CORBA.portable.OutputStream $out = _request ("getMapMURROD", true);
01385                 $out.write_ulong (MUR);
01386                 $in = _invoke ($out);
01387                 partition.value = $in.read_ulong ();
01388                 crate.value = $in.read_ulong ();
01389                 rod.value = $in.read_ulong ();
01390                 order.value = $in.read_ulong ();
01391                 return;
01392             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01393                 $in = $ex.getInputStream ();
01394                 String _id = $ex.getId ();
01395                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01396                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01397                 else
01398                     throw new org.omg.CORBA.MARSHAL (_id);
01399             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01400                 getMapMURROD (MUR, partition, crate, rod, order        );
01401             } finally {
01402                 _releaseReply ($in);
01403             }
01404   } // getMapMURROD
01405 
01406   public void getMapRODMUR (int partition, int crate, int rod, int order, org.omg.CORBA.IntHolder MUR) throws sctConf.ConfigurationException
01407   {
01408             org.omg.CORBA.portable.InputStream $in = null;
01409             try {
01410                 org.omg.CORBA.portable.OutputStream $out = _request ("getMapRODMUR", true);
01411                 $out.write_ulong (partition);
01412                 $out.write_ulong (crate);
01413                 $out.write_ulong (rod);
01414                 $out.write_ulong (order);
01415                 $in = _invoke ($out);
01416                 MUR.value = $in.read_ulong ();
01417                 return;
01418             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01419                 $in = $ex.getInputStream ();
01420                 String _id = $ex.getId ();
01421                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01422                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01423                 else
01424                     throw new org.omg.CORBA.MARSHAL (_id);
01425             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01426                 getMapRODMUR (partition, crate, rod, order, MUR        );
01427             } finally {
01428                 _releaseReply ($in);
01429             }
01430   } // getMapRODMUR
01431 
01432   public sctConf.MURType getMapMURPhysical (int MUR, org.omg.CORBA.IntHolder plane, org.omg.CORBA.IntHolder section, org.omg.CORBA.IntHolder position) throws sctConf.ConfigurationException
01433   {
01434             org.omg.CORBA.portable.InputStream $in = null;
01435             try {
01436                 org.omg.CORBA.portable.OutputStream $out = _request ("getMapMURPhysical", true);
01437                 $out.write_ulong (MUR);
01438                 $in = _invoke ($out);
01439                 sctConf.MURType $result = sctConf.MURTypeHelper.read ($in);
01440                 plane.value = $in.read_ulong ();
01441                 section.value = $in.read_ulong ();
01442                 position.value = $in.read_ulong ();
01443                 return $result;
01444             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01445                 $in = $ex.getInputStream ();
01446                 String _id = $ex.getId ();
01447                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01448                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01449                 else
01450                     throw new org.omg.CORBA.MARSHAL (_id);
01451             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01452                 return getMapMURPhysical (MUR, plane, section, position        );
01453             } finally {
01454                 _releaseReply ($in);
01455             }
01456   } // getMapMURPhysical
01457 
01458   public void swapMURNames (int MUR1, int MUR2) throws sctConf.ConfigurationException
01459   {
01460             org.omg.CORBA.portable.InputStream $in = null;
01461             try {
01462                 org.omg.CORBA.portable.OutputStream $out = _request ("swapMURNames", true);
01463                 $out.write_ulong (MUR1);
01464                 $out.write_ulong (MUR2);
01465                 $in = _invoke ($out);
01466                 return;
01467             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01468                 $in = $ex.getInputStream ();
01469                 String _id = $ex.getId ();
01470                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01471                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01472                 else
01473                     throw new org.omg.CORBA.MARSHAL (_id);
01474             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01475                 swapMURNames (MUR1, MUR2        );
01476             } finally {
01477                 _releaseReply ($in);
01478             }
01479   } // swapMURNames
01480 
01481   public void modifyDefaultPowerParam (String state, String name, String type, float value) throws sctConf.ConfigurationException
01482   {
01483             org.omg.CORBA.portable.InputStream $in = null;
01484             try {
01485                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyDefaultPowerParam", true);
01486                 $out.write_string (state);
01487                 $out.write_string (name);
01488                 $out.write_string (type);
01489                 $out.write_float (value);
01490                 $in = _invoke ($out);
01491                 return;
01492             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01493                 $in = $ex.getInputStream ();
01494                 String _id = $ex.getId ();
01495                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01496                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01497                 else
01498                     throw new org.omg.CORBA.MARSHAL (_id);
01499             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01500                 modifyDefaultPowerParam (state, name, type, value        );
01501             } finally {
01502                 _releaseReply ($in);
01503             }
01504   } // modifyDefaultPowerParam
01505 
01506   public void modifyHVCardParam (int crate, int card, String name, String type, float value) throws sctConf.ConfigurationException
01507   {
01508             org.omg.CORBA.portable.InputStream $in = null;
01509             try {
01510                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyHVCardParam", true);
01511                 $out.write_ulong (crate);
01512                 $out.write_ulong (card);
01513                 $out.write_string (name);
01514                 $out.write_string (type);
01515                 $out.write_float (value);
01516                 $in = _invoke ($out);
01517                 return;
01518             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01519                 $in = $ex.getInputStream ();
01520                 String _id = $ex.getId ();
01521                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01522                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01523                 else
01524                     throw new org.omg.CORBA.MARSHAL (_id);
01525             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01526                 modifyHVCardParam (crate, card, name, type, value        );
01527             } finally {
01528                 _releaseReply ($in);
01529             }
01530   } // modifyHVCardParam
01531 
01532   public void modifyLVCardParam (int crate, int card, String name, String type, float value) throws sctConf.ConfigurationException
01533   {
01534             org.omg.CORBA.portable.InputStream $in = null;
01535             try {
01536                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyLVCardParam", true);
01537                 $out.write_ulong (crate);
01538                 $out.write_ulong (card);
01539                 $out.write_string (name);
01540                 $out.write_string (type);
01541                 $out.write_float (value);
01542                 $in = _invoke ($out);
01543                 return;
01544             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01545                 $in = $ex.getInputStream ();
01546                 String _id = $ex.getId ();
01547                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01548                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01549                 else
01550                     throw new org.omg.CORBA.MARSHAL (_id);
01551             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01552                 modifyLVCardParam (crate, card, name, type, value        );
01553             } finally {
01554                 _releaseReply ($in);
01555             }
01556   } // modifyLVCardParam
01557 
01558   public void modifyPowerParam (int MUR, int number, String state, String name, String type, float value) throws sctConf.ConfigurationException
01559   {
01560             org.omg.CORBA.portable.InputStream $in = null;
01561             try {
01562                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyPowerParam", true);
01563                 $out.write_ulong (MUR);
01564                 $out.write_ulong (number);
01565                 $out.write_string (state);
01566                 $out.write_string (name);
01567                 $out.write_string (type);
01568                 $out.write_float (value);
01569                 $in = _invoke ($out);
01570                 return;
01571             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01572                 $in = $ex.getInputStream ();
01573                 String _id = $ex.getId ();
01574                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01575                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01576                 else
01577                     throw new org.omg.CORBA.MARSHAL (_id);
01578             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01579                 modifyPowerParam (MUR, number, state, name, type, value        );
01580             } finally {
01581                 _releaseReply ($in);
01582             }
01583   } // modifyPowerParam
01584 
01585   public void modifyPowerParamCC (int crate, int channel, String state, String name, String type, float value) throws sctConf.ConfigurationException
01586   {
01587             org.omg.CORBA.portable.InputStream $in = null;
01588             try {
01589                 org.omg.CORBA.portable.OutputStream $out = _request ("modifyPowerParamCC", true);
01590                 $out.write_ulong (crate);
01591                 $out.write_ulong (channel);
01592                 $out.write_string (state);
01593                 $out.write_string (name);
01594                 $out.write_string (type);
01595                 $out.write_float (value);
01596                 $in = _invoke ($out);
01597                 return;
01598             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01599                 $in = $ex.getInputStream ();
01600                 String _id = $ex.getId ();
01601                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01602                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01603                 else
01604                     throw new org.omg.CORBA.MARSHAL (_id);
01605             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01606                 modifyPowerParamCC (crate, channel, state, name, type, value        );
01607             } finally {
01608                 _releaseReply ($in);
01609             }
01610   } // modifyPowerParamCC
01611 
01612   public float getDefaultPowerParam (String state, String name, String type) throws sctConf.ConfigurationException
01613   {
01614             org.omg.CORBA.portable.InputStream $in = null;
01615             try {
01616                 org.omg.CORBA.portable.OutputStream $out = _request ("getDefaultPowerParam", true);
01617                 $out.write_string (state);
01618                 $out.write_string (name);
01619                 $out.write_string (type);
01620                 $in = _invoke ($out);
01621                 float $result = $in.read_float ();
01622                 return $result;
01623             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01624                 $in = $ex.getInputStream ();
01625                 String _id = $ex.getId ();
01626                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01627                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01628                 else
01629                     throw new org.omg.CORBA.MARSHAL (_id);
01630             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01631                 return getDefaultPowerParam (state, name, type        );
01632             } finally {
01633                 _releaseReply ($in);
01634             }
01635   } // getDefaultPowerParam
01636 
01637   public float getHVCardParam (int crate, int card, String name, String type) throws sctConf.ConfigurationException
01638   {
01639             org.omg.CORBA.portable.InputStream $in = null;
01640             try {
01641                 org.omg.CORBA.portable.OutputStream $out = _request ("getHVCardParam", true);
01642                 $out.write_ulong (crate);
01643                 $out.write_ulong (card);
01644                 $out.write_string (name);
01645                 $out.write_string (type);
01646                 $in = _invoke ($out);
01647                 float $result = $in.read_float ();
01648                 return $result;
01649             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01650                 $in = $ex.getInputStream ();
01651                 String _id = $ex.getId ();
01652                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01653                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01654                 else
01655                     throw new org.omg.CORBA.MARSHAL (_id);
01656             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01657                 return getHVCardParam (crate, card, name, type        );
01658             } finally {
01659                 _releaseReply ($in);
01660             }
01661   } // getHVCardParam
01662 
01663 
01670   public float getLVCardParam (int crate, int card, String name, String type) throws sctConf.ConfigurationException
01671   {
01672             org.omg.CORBA.portable.InputStream $in = null;
01673             try {
01674                 org.omg.CORBA.portable.OutputStream $out = _request ("getLVCardParam", true);
01675                 $out.write_ulong (crate);
01676                 $out.write_ulong (card);
01677                 $out.write_string (name);
01678                 $out.write_string (type);
01679                 $in = _invoke ($out);
01680                 float $result = $in.read_float ();
01681                 return $result;
01682             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01683                 $in = $ex.getInputStream ();
01684                 String _id = $ex.getId ();
01685                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01686                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01687                 else
01688                     throw new org.omg.CORBA.MARSHAL (_id);
01689             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01690                 return getLVCardParam (crate, card, name, type        );
01691             } finally {
01692                 _releaseReply ($in);
01693             }
01694   } // getLVCardParam
01695 
01696 
01704   public float getPowerParam (int MUR, int number, String state, String name, String type) throws sctConf.ConfigurationException
01705   {
01706             org.omg.CORBA.portable.InputStream $in = null;
01707             try {
01708                 org.omg.CORBA.portable.OutputStream $out = _request ("getPowerParam", true);
01709                 $out.write_ulong (MUR);
01710                 $out.write_ulong (number);
01711                 $out.write_string (state);
01712                 $out.write_string (name);
01713                 $out.write_string (type);
01714                 $in = _invoke ($out);
01715                 float $result = $in.read_float ();
01716                 return $result;
01717             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01718                 $in = $ex.getInputStream ();
01719                 String _id = $ex.getId ();
01720                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01721                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01722                 else
01723                     throw new org.omg.CORBA.MARSHAL (_id);
01724             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01725                 return getPowerParam (MUR, number, state, name, type        );
01726             } finally {
01727                 _releaseReply ($in);
01728             }
01729   } // getPowerParam
01730 
01731 
01739   public float getPowerParamCC (int crate, int channel, String state, String name, String type) throws sctConf.ConfigurationException
01740   {
01741             org.omg.CORBA.portable.InputStream $in = null;
01742             try {
01743                 org.omg.CORBA.portable.OutputStream $out = _request ("getPowerParamCC", true);
01744                 $out.write_ulong (crate);
01745                 $out.write_ulong (channel);
01746                 $out.write_string (state);
01747                 $out.write_string (name);
01748                 $out.write_string (type);
01749                 $in = _invoke ($out);
01750                 float $result = $in.read_float ();
01751                 return $result;
01752             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01753                 $in = $ex.getInputStream ();
01754                 String _id = $ex.getId ();
01755                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01756                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01757                 else
01758                     throw new org.omg.CORBA.MARSHAL (_id);
01759             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01760                 return getPowerParamCC (crate, channel, state, name, type        );
01761             } finally {
01762                 _releaseReply ($in);
01763             }
01764   } // getPowerParamCC
01765 
01766   public String[] listDefaultPowerParams () throws sctConf.ConfigurationException
01767   {
01768             org.omg.CORBA.portable.InputStream $in = null;
01769             try {
01770                 org.omg.CORBA.portable.OutputStream $out = _request ("listDefaultPowerParams", true);
01771                 $in = _invoke ($out);
01772                 String $result[] = sctConf.NameListHelper.read ($in);
01773                 return $result;
01774             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01775                 $in = $ex.getInputStream ();
01776                 String _id = $ex.getId ();
01777                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01778                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01779                 else
01780                     throw new org.omg.CORBA.MARSHAL (_id);
01781             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01782                 return listDefaultPowerParams (        );
01783             } finally {
01784                 _releaseReply ($in);
01785             }
01786   } // listDefaultPowerParams
01787 
01788   public float getCratePowerParam (int crate, String name) throws sctConf.ConfigurationException
01789   {
01790             org.omg.CORBA.portable.InputStream $in = null;
01791             try {
01792                 org.omg.CORBA.portable.OutputStream $out = _request ("getCratePowerParam", true);
01793                 $out.write_ulong (crate);
01794                 $out.write_string (name);
01795                 $in = _invoke ($out);
01796                 float $result = $in.read_float ();
01797                 return $result;
01798             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01799                 $in = $ex.getInputStream ();
01800                 String _id = $ex.getId ();
01801                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01802                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01803                 else
01804                     throw new org.omg.CORBA.MARSHAL (_id);
01805             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01806                 return getCratePowerParam (crate, name        );
01807             } finally {
01808                 _releaseReply ($in);
01809             }
01810   } // getCratePowerParam
01811 
01812   public String[] listDCSChannelParams () throws sctConf.ConfigurationException
01813   {
01814             org.omg.CORBA.portable.InputStream $in = null;
01815             try {
01816                 org.omg.CORBA.portable.OutputStream $out = _request ("listDCSChannelParams", true);
01817                 $in = _invoke ($out);
01818                 String $result[] = sctConf.NameListHelper.read ($in);
01819                 return $result;
01820             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01821                 $in = $ex.getInputStream ();
01822                 String _id = $ex.getId ();
01823                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01824                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01825                 else
01826                     throw new org.omg.CORBA.MARSHAL (_id);
01827             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01828                 return listDCSChannelParams (        );
01829             } finally {
01830                 _releaseReply ($in);
01831             }
01832   } // listDCSChannelParams
01833 
01834   public String[] listDCSCardParams () throws sctConf.ConfigurationException
01835   {
01836             org.omg.CORBA.portable.InputStream $in = null;
01837             try {
01838                 org.omg.CORBA.portable.OutputStream $out = _request ("listDCSCardParams", true);
01839                 $in = _invoke ($out);
01840                 String $result[] = sctConf.NameListHelper.read ($in);
01841                 return $result;
01842             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01843                 $in = $ex.getInputStream ();
01844                 String _id = $ex.getId ();
01845                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01846                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01847                 else
01848                     throw new org.omg.CORBA.MARSHAL (_id);
01849             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01850                 return listDCSCardParams (        );
01851             } finally {
01852                 _releaseReply ($in);
01853             }
01854   } // listDCSCardParams
01855 
01856   public String[] listDCSCrateParams () throws sctConf.ConfigurationException
01857   {
01858             org.omg.CORBA.portable.InputStream $in = null;
01859             try {
01860                 org.omg.CORBA.portable.OutputStream $out = _request ("listDCSCrateParams", true);
01861                 $in = _invoke ($out);
01862                 String $result[] = sctConf.NameListHelper.read ($in);
01863                 return $result;
01864             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01865                 $in = $ex.getInputStream ();
01866                 String _id = $ex.getId ();
01867                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01868                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01869                 else
01870                     throw new org.omg.CORBA.MARSHAL (_id);
01871             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01872                 return listDCSCrateParams (        );
01873             } finally {
01874                 _releaseReply ($in);
01875             }
01876   } // listDCSCrateParams
01877 
01878   public void configureBOCChannel (int MUR, int position, sctConf.BOCChannelConfig conf) throws sctConf.ConfigurationException
01879   {
01880             org.omg.CORBA.portable.InputStream $in = null;
01881             try {
01882                 org.omg.CORBA.portable.OutputStream $out = _request ("configureBOCChannel", true);
01883                 $out.write_ulong (MUR);
01884                 $out.write_ulong (position);
01885                 sctConf.BOCChannelConfigHelper.write ($out, conf);
01886                 $in = _invoke ($out);
01887                 return;
01888             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01889                 $in = $ex.getInputStream ();
01890                 String _id = $ex.getId ();
01891                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01892                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01893                 else
01894                     throw new org.omg.CORBA.MARSHAL (_id);
01895             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01896                 configureBOCChannel (MUR, position, conf        );
01897             } finally {
01898                 _releaseReply ($in);
01899             }
01900   } // configureBOCChannel
01901 
01902   public void loadConfiguration (String filename) throws sctConf.ConfigurationException
01903   {
01904             org.omg.CORBA.portable.InputStream $in = null;
01905             try {
01906                 org.omg.CORBA.portable.OutputStream $out = _request ("loadConfiguration", true);
01907                 $out.write_string (filename);
01908                 $in = _invoke ($out);
01909                 return;
01910             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01911                 $in = $ex.getInputStream ();
01912                 String _id = $ex.getId ();
01913                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01914                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01915                 else
01916                     throw new org.omg.CORBA.MARSHAL (_id);
01917             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01918                 loadConfiguration (filename        );
01919             } finally {
01920                 _releaseReply ($in);
01921             }
01922   } // loadConfiguration
01923 
01924   public void saveConfiguration (String filename) throws sctConf.ConfigurationException
01925   {
01926             org.omg.CORBA.portable.InputStream $in = null;
01927             try {
01928                 org.omg.CORBA.portable.OutputStream $out = _request ("saveConfiguration", true);
01929                 $out.write_string (filename);
01930                 $in = _invoke ($out);
01931                 return;
01932             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01933                 $in = $ex.getInputStream ();
01934                 String _id = $ex.getId ();
01935                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01936                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01937                 else
01938                     throw new org.omg.CORBA.MARSHAL (_id);
01939             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01940                 saveConfiguration (filename        );
01941             } finally {
01942                 _releaseReply ($in);
01943             }
01944   } // saveConfiguration
01945 
01946   public void saveModuleConfiguration (String sn, String filename) throws sctConf.ConfigurationException
01947   {
01948             org.omg.CORBA.portable.InputStream $in = null;
01949             try {
01950                 org.omg.CORBA.portable.OutputStream $out = _request ("saveModuleConfiguration", true);
01951                 $out.write_string (sn);
01952                 $out.write_string (filename);
01953                 $in = _invoke ($out);
01954                 return;
01955             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01956                 $in = $ex.getInputStream ();
01957                 String _id = $ex.getId ();
01958                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01959                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01960                 else
01961                     throw new org.omg.CORBA.MARSHAL (_id);
01962             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01963                 saveModuleConfiguration (sn, filename        );
01964             } finally {
01965                 _releaseReply ($in);
01966             }
01967   } // saveModuleConfiguration
01968 
01969   public String getModuleConfigurationString (String modsn, sctConf.ABCDModule config) throws sctConf.ConfigurationException
01970   {
01971             org.omg.CORBA.portable.InputStream $in = null;
01972             try {
01973                 org.omg.CORBA.portable.OutputStream $out = _request ("getModuleConfigurationString", true);
01974                 $out.write_string (modsn);
01975                 sctConf.ABCDModuleHelper.write ($out, config);
01976                 $in = _invoke ($out);
01977                 String $result = $in.read_string ();
01978                 return $result;
01979             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
01980                 $in = $ex.getInputStream ();
01981                 String _id = $ex.getId ();
01982                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
01983                     throw sctConf.ConfigurationExceptionHelper.read ($in);
01984                 else
01985                     throw new org.omg.CORBA.MARSHAL (_id);
01986             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
01987                 return getModuleConfigurationString (modsn, config        );
01988             } finally {
01989                 _releaseReply ($in);
01990             }
01991   } // getModuleConfigurationString
01992 
01993   public void writePowerSupplyConfiguration (String directory) throws sctConf.ConfigurationException
01994   {
01995             org.omg.CORBA.portable.InputStream $in = null;
01996             try {
01997                 org.omg.CORBA.portable.OutputStream $out = _request ("writePowerSupplyConfiguration", true);
01998                 $out.write_string (directory);
01999                 $in = _invoke ($out);
02000                 return;
02001             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02002                 $in = $ex.getInputStream ();
02003                 String _id = $ex.getId ();
02004                 if (_id.equals ("IDL:sctConf/ConfigurationException:1.0"))
02005                     throw sctConf.ConfigurationExceptionHelper.read ($in);
02006                 else
02007                     throw new org.omg.CORBA.MARSHAL (_id);
02008             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02009                 writePowerSupplyConfiguration (directory        );
02010             } finally {
02011                 _releaseReply ($in);
02012             }
02013   } // writePowerSupplyConfiguration
02014 
02015   public void get_info (ipc.InfoHolder inf)
02016   {
02017             org.omg.CORBA.portable.InputStream $in = null;
02018             try {
02019                 org.omg.CORBA.portable.OutputStream $out = _request ("get_info", true);
02020                 $in = _invoke ($out);
02021                 inf.value = ipc.InfoHelper.read ($in);
02022                 return;
02023             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02024                 $in = $ex.getInputStream ();
02025                 String _id = $ex.getId ();
02026                 throw new org.omg.CORBA.MARSHAL (_id);
02027             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02028                 get_info (inf        );
02029             } finally {
02030                 _releaseReply ($in);
02031             }
02032   } // get_info
02033 
02034   public void destroy ()
02035   {
02036             org.omg.CORBA.portable.InputStream $in = null;
02037             try {
02038                 org.omg.CORBA.portable.OutputStream $out = _request ("destroy", false);
02039                 $in = _invoke ($out);
02040                 return;
02041             } catch (org.omg.CORBA.portable.ApplicationException $ex) {
02042                 $in = $ex.getInputStream ();
02043                 String _id = $ex.getId ();
02044                 throw new org.omg.CORBA.MARSHAL (_id);
02045             } catch (org.omg.CORBA.portable.RemarshalException $rm) {
02046                 destroy (        );
02047             } finally {
02048                 _releaseReply ($in);
02049             }
02050   } // destroy
02051 
02052   // Type-specific CORBA::Object operations
02053   private static String[] __ids = {
02054     "IDL:sctConf/Configuration:1.0", 
02055     "IDL:ipc/freeable:1.0"};
02056 
02057   public String[] _ids ()
02058   {
02059     return (String[])__ids.clone ();
02060   }
02061 
02062   private void readObject (java.io.ObjectInputStream s) throws java.io.IOException
02063   {
02064      String str = s.readUTF ();
02065      String[] args = null;
02066      java.util.Properties props = null;
02067      org.omg.CORBA.Object obj = org.omg.CORBA.ORB.init (args, props).string_to_object (str);
02068      org.omg.CORBA.portable.Delegate delegate = ((org.omg.CORBA.portable.ObjectImpl) obj)._get_delegate ();
02069      _set_delegate (delegate);
02070   }
02071 
02072   private void writeObject (java.io.ObjectOutputStream s) throws java.io.IOException
02073   {
02074      String[] args = null;
02075      java.util.Properties props = null;
02076      String str = org.omg.CORBA.ORB.init (args, props).object_to_string (this);
02077      s.writeUTF (str);
02078   }
02079 } // class _ConfigurationStub

Generated on Fri Jan 14 12:49:49 2005 for SCT DAQ/DCS Software - Java by doxygen 1.3.5