1 // Copyright (c) 2000, 2001 NEC Corporation.

     2 

     3 // Adapted for Mauve by Audrius Meskauskas <audriusa@bluewin.ch>

     4 

     5 // This file is part of Mauve.

     6 

     7 // Mauve is free software; you can redistribute it and/or modify

     8 // it under the terms of the GNU General Public License as published by

     9 // the Free Software Foundation; either version 2, or (at your option)

    10 // any later version.

    11 

    12 // Mauve is distributed in the hope that it will be useful,

    13 // but WITHOUT ANY WARRANTY; without even the implied warranty of

    14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15 // GNU General Public License for more details.

    16 

    17 // You should have received a copy of the GNU General Public License

    18 // along with Mauve; see the file COPYING.  If not, write to

    19 // the Free Software Foundation, 59 Temple Place - Suite 330,

    20 // Boston, MA 02111-1307, USA.

    21 

    22 /*

    23 This code originally came from the OMG's CORBA Open Source Testing project,

    24 which lived at cost.omg.org. That site no longer exists.

    25 

    26 All the contributing companies agreed to release their tests under the

    27 terms of the GNU Lesser General Public License, available in the file

    28 COPYING.LIB.

    29 

    30 The code has been modified integrating into Mauve test environment and

    31 removing tests that are not yet supported by Suns jre 1.4. Hence the license

    32 is now GPL.

    33 

    34 We downloaded the code from http://sourceforge.net/projects/corba-cost/,

    35 administrated by Duncan Grisby.

    36 */

    37 

    38 

    39 package gnu.testlet.org.omg.CORBA.ORB.RF11;

    40 

    41 public final class F_union

    42   implements org.omg.CORBA.portable.IDLEntity

    43 {

    44   private C_struct ___e_c_struct;

    45   private C_union ___e_c_union;

    46   private short[] ___e_c_sequence_e_short;

    47   private short[] ___e_c_sequence_e_ushort;

    48   private int[] ___e_c_sequence_e_long;

    49   private int[] ___e_c_sequence_e_ulong;

    50   private float[] ___e_c_sequence_e_float;

    51   private double[] ___e_c_sequence_e_double;

    52   private char[] ___e_c_sequence_e_char;

    53   private boolean[] ___e_c_sequence_e_boolean;

    54   private byte[] ___e_c_sequence_e_octet;

    55   private org.omg.CORBA.Any[] ___e_c_sequence_e_any;

    56   private String[] ___e_c_sequence_e_string;

    57   private org.omg.CORBA.Object[] ___e_c_sequence_e_Object;

    58   private short[] ___e_c_array_e_short;

    59   private short[] ___e_c_array_e_ushort;

    60   private int[] ___e_c_array_e_long;

    61   private int[] ___e_c_array_e_ulong;

    62   private float[] ___e_c_array_e_float;

    63   private double[] ___e_c_array_e_double;

    64   private char[] ___e_c_array_e_char;

    65   private boolean[] ___e_c_array_e_boolean;

    66   private byte[] ___e_c_array_e_octet;

    67   private org.omg.CORBA.Any[] ___e_c_array_e_any;

    68   private String[] ___e_c_array_e_string;

    69   private org.omg.CORBA.Object[] ___e_c_array_e_Object;

    70   private int __discriminator;

    71   private boolean __uninitialized = true;

    72 

    73   public F_union()

    74   {

    75   }

    76 

    77   public int discriminator()

    78   {

    79     if (__uninitialized)

    80       throw new org.omg.CORBA.BAD_OPERATION();

    81     return __discriminator;

    82   }

    83 

    84   public C_struct e_c_struct()

    85   {

    86     if (__uninitialized)

    87       throw new org.omg.CORBA.BAD_OPERATION();

    88     verifye_c_struct(__discriminator);

    89     return ___e_c_struct;

    90   }

    91 

    92   public void e_c_struct(C_struct value)

    93   {

    94     __discriminator = 1;

    95     ___e_c_struct = value;

    96     __uninitialized = false;

    97   }

    98 

    99   private void verifye_c_struct(int discriminator)

   100   {

   101     if (discriminator != 1)

   102       throw new org.omg.CORBA.BAD_OPERATION();

   103   }

   104 

   105   public C_union e_c_union()

   106   {

   107     if (__uninitialized)

   108       throw new org.omg.CORBA.BAD_OPERATION();

   109     verifye_c_union(__discriminator);

   110     return ___e_c_union;

   111   }

   112 

   113   public void e_c_union(C_union value)

   114   {

   115     __discriminator = 2;

   116     ___e_c_union = value;

   117     __uninitialized = false;

   118   }

   119 

   120   private void verifye_c_union(int discriminator)

   121   {

   122     if (discriminator != 2)

   123       throw new org.omg.CORBA.BAD_OPERATION();

   124   }

   125 

   126   public short[] e_c_sequence_e_short()

   127   {

   128     if (__uninitialized)

   129       throw new org.omg.CORBA.BAD_OPERATION();

   130     verifye_c_sequence_e_short(__discriminator);

   131     return ___e_c_sequence_e_short;

   132   }

   133 

   134   public void e_c_sequence_e_short(short[] value)

   135   {

   136     __discriminator = 3;

   137     ___e_c_sequence_e_short = value;

   138     __uninitialized = false;

   139   }

   140 

   141   private void verifye_c_sequence_e_short(int discriminator)

   142   {

   143     if (discriminator != 3)

   144       throw new org.omg.CORBA.BAD_OPERATION();

   145   }

   146 

   147   public short[] e_c_sequence_e_ushort()

   148   {

   149     if (__uninitialized)

   150       throw new org.omg.CORBA.BAD_OPERATION();

   151     verifye_c_sequence_e_ushort(__discriminator);

   152     return ___e_c_sequence_e_ushort;

   153   }

   154 

   155   public void e_c_sequence_e_ushort(short[] value)

   156   {

   157     __discriminator = 4;

   158     ___e_c_sequence_e_ushort = value;

   159     __uninitialized = false;

   160   }

   161 

   162   private void verifye_c_sequence_e_ushort(int discriminator)

   163   {

   164     if (discriminator != 4)

   165       throw new org.omg.CORBA.BAD_OPERATION();

   166   }

   167 

   168   public int[] e_c_sequence_e_long()

   169   {

   170     if (__uninitialized)

   171       throw new org.omg.CORBA.BAD_OPERATION();

   172     verifye_c_sequence_e_long(__discriminator);

   173     return ___e_c_sequence_e_long;

   174   }

   175 

   176   public void e_c_sequence_e_long(int[] value)

   177   {

   178     __discriminator = 5;

   179     ___e_c_sequence_e_long = value;

   180     __uninitialized = false;

   181   }

   182 

   183   private void verifye_c_sequence_e_long(int discriminator)

   184   {

   185     if (discriminator != 5)

   186       throw new org.omg.CORBA.BAD_OPERATION();

   187   }

   188 

   189   public int[] e_c_sequence_e_ulong()

   190   {

   191     if (__uninitialized)

   192       throw new org.omg.CORBA.BAD_OPERATION();

   193     verifye_c_sequence_e_ulong(__discriminator);

   194     return ___e_c_sequence_e_ulong;

   195   }

   196 

   197   public void e_c_sequence_e_ulong(int[] value)

   198   {

   199     __discriminator = 6;

   200     ___e_c_sequence_e_ulong = value;

   201     __uninitialized = false;

   202   }

   203 

   204   private void verifye_c_sequence_e_ulong(int discriminator)

   205   {

   206     if (discriminator != 6)

   207       throw new org.omg.CORBA.BAD_OPERATION();

   208   }

   209 

   210   public float[] e_c_sequence_e_float()

   211   {

   212     if (__uninitialized)

   213       throw new org.omg.CORBA.BAD_OPERATION();

   214     verifye_c_sequence_e_float(__discriminator);

   215     return ___e_c_sequence_e_float;

   216   }

   217 

   218   public void e_c_sequence_e_float(float[] value)

   219   {

   220     __discriminator = 7;

   221     ___e_c_sequence_e_float = value;

   222     __uninitialized = false;

   223   }

   224 

   225   private void verifye_c_sequence_e_float(int discriminator)

   226   {

   227     if (discriminator != 7)

   228       throw new org.omg.CORBA.BAD_OPERATION();

   229   }

   230 

   231   public double[] e_c_sequence_e_double()

   232   {

   233     if (__uninitialized)

   234       throw new org.omg.CORBA.BAD_OPERATION();

   235     verifye_c_sequence_e_double(__discriminator);

   236     return ___e_c_sequence_e_double;

   237   }

   238 

   239   public void e_c_sequence_e_double(double[] value)

   240   {

   241     __discriminator = 8;

   242     ___e_c_sequence_e_double = value;

   243     __uninitialized = false;

   244   }

   245 

   246   private void verifye_c_sequence_e_double(int discriminator)

   247   {

   248     if (discriminator != 8)

   249       throw new org.omg.CORBA.BAD_OPERATION();

   250   }

   251 

   252   public char[] e_c_sequence_e_char()

   253   {

   254     if (__uninitialized)

   255       throw new org.omg.CORBA.BAD_OPERATION();

   256     verifye_c_sequence_e_char(__discriminator);

   257     return ___e_c_sequence_e_char;

   258   }

   259 

   260   public void e_c_sequence_e_char(char[] value)

   261   {

   262     __discriminator = 9;

   263     ___e_c_sequence_e_char = value;

   264     __uninitialized = false;

   265   }

   266 

   267   private void verifye_c_sequence_e_char(int discriminator)

   268   {

   269     if (discriminator != 9)

   270       throw new org.omg.CORBA.BAD_OPERATION();

   271   }

   272 

   273   public boolean[] e_c_sequence_e_boolean()

   274   {

   275     if (__uninitialized)

   276       throw new org.omg.CORBA.BAD_OPERATION();

   277     verifye_c_sequence_e_boolean(__discriminator);

   278     return ___e_c_sequence_e_boolean;

   279   }

   280 

   281   public void e_c_sequence_e_boolean(boolean[] value)

   282   {

   283     __discriminator = 10;

   284     ___e_c_sequence_e_boolean = value;

   285     __uninitialized = false;

   286   }

   287 

   288   private void verifye_c_sequence_e_boolean(int discriminator)

   289   {

   290     if (discriminator != 10)

   291       throw new org.omg.CORBA.BAD_OPERATION();

   292   }

   293 

   294   public byte[] e_c_sequence_e_octet()

   295   {

   296     if (__uninitialized)

   297       throw new org.omg.CORBA.BAD_OPERATION();

   298     verifye_c_sequence_e_octet(__discriminator);

   299     return ___e_c_sequence_e_octet;

   300   }

   301 

   302   public void e_c_sequence_e_octet(byte[] value)

   303   {

   304     __discriminator = 11;

   305     ___e_c_sequence_e_octet = value;

   306     __uninitialized = false;

   307   }

   308 

   309   private void verifye_c_sequence_e_octet(int discriminator)

   310   {

   311     if (discriminator != 11)

   312       throw new org.omg.CORBA.BAD_OPERATION();

   313   }

   314 

   315   public org.omg.CORBA.Any[] e_c_sequence_e_any()

   316   {

   317     if (__uninitialized)

   318       throw new org.omg.CORBA.BAD_OPERATION();

   319     verifye_c_sequence_e_any(__discriminator);

   320     return ___e_c_sequence_e_any;

   321   }

   322 

   323   public void e_c_sequence_e_any(org.omg.CORBA.Any[] value)

   324   {

   325     __discriminator = 12;

   326     ___e_c_sequence_e_any = value;

   327     __uninitialized = false;

   328   }

   329 

   330   private void verifye_c_sequence_e_any(int discriminator)

   331   {

   332     if (discriminator != 12)

   333       throw new org.omg.CORBA.BAD_OPERATION();

   334   }

   335 

   336   public String[] e_c_sequence_e_string()

   337   {

   338     if (__uninitialized)

   339       throw new org.omg.CORBA.BAD_OPERATION();

   340     verifye_c_sequence_e_string(__discriminator);

   341     return ___e_c_sequence_e_string;

   342   }

   343 

   344   public void e_c_sequence_e_string(String[] value)

   345   {

   346     __discriminator = 13;

   347     ___e_c_sequence_e_string = value;

   348     __uninitialized = false;

   349   }

   350 

   351   private void verifye_c_sequence_e_string(int discriminator)

   352   {

   353     if (discriminator != 13)

   354       throw new org.omg.CORBA.BAD_OPERATION();

   355   }

   356 

   357   public org.omg.CORBA.Object[] e_c_sequence_e_Object()

   358   {

   359     if (__uninitialized)

   360       throw new org.omg.CORBA.BAD_OPERATION();

   361     verifye_c_sequence_e_Object(__discriminator);

   362     return ___e_c_sequence_e_Object;

   363   }

   364 

   365   public void e_c_sequence_e_Object(org.omg.CORBA.Object[] value)

   366   {

   367     __discriminator = 14;

   368     ___e_c_sequence_e_Object = value;

   369     __uninitialized = false;

   370   }

   371 

   372   private void verifye_c_sequence_e_Object(int discriminator)

   373   {

   374     if (discriminator != 14)

   375       throw new org.omg.CORBA.BAD_OPERATION();

   376   }

   377 

   378   public short[] e_c_array_e_short()

   379   {

   380     if (__uninitialized)

   381       throw new org.omg.CORBA.BAD_OPERATION();

   382     verifye_c_array_e_short(__discriminator);

   383     return ___e_c_array_e_short;

   384   }

   385 

   386   public void e_c_array_e_short(short[] value)

   387   {

   388     __discriminator = 17;

   389     ___e_c_array_e_short = value;

   390     __uninitialized = false;

   391   }

   392 

   393   private void verifye_c_array_e_short(int discriminator)

   394   {

   395     if (discriminator != 17)

   396       throw new org.omg.CORBA.BAD_OPERATION();

   397   }

   398 

   399   public short[] e_c_array_e_ushort()

   400   {

   401     if (__uninitialized)

   402       throw new org.omg.CORBA.BAD_OPERATION();

   403     verifye_c_array_e_ushort(__discriminator);

   404     return ___e_c_array_e_ushort;

   405   }

   406 

   407   public void e_c_array_e_ushort(short[] value)

   408   {

   409     __discriminator = 18;

   410     ___e_c_array_e_ushort = value;

   411     __uninitialized = false;

   412   }

   413 

   414   private void verifye_c_array_e_ushort(int discriminator)

   415   {

   416     if (discriminator != 18)

   417       throw new org.omg.CORBA.BAD_OPERATION();

   418   }

   419 

   420   public int[] e_c_array_e_long()

   421   {

   422     if (__uninitialized)

   423       throw new org.omg.CORBA.BAD_OPERATION();

   424     verifye_c_array_e_long(__discriminator);

   425     return ___e_c_array_e_long;

   426   }

   427 

   428   public void e_c_array_e_long(int[] value)

   429   {

   430     __discriminator = 19;

   431     ___e_c_array_e_long = value;

   432     __uninitialized = false;

   433   }

   434 

   435   private void verifye_c_array_e_long(int discriminator)

   436   {

   437     if (discriminator != 19)

   438       throw new org.omg.CORBA.BAD_OPERATION();

   439   }

   440 

   441   public int[] e_c_array_e_ulong()

   442   {

   443     if (__uninitialized)

   444       throw new org.omg.CORBA.BAD_OPERATION();

   445     verifye_c_array_e_ulong(__discriminator);

   446     return ___e_c_array_e_ulong;

   447   }

   448 

   449   public void e_c_array_e_ulong(int[] value)

   450   {

   451     __discriminator = 20;

   452     ___e_c_array_e_ulong = value;

   453     __uninitialized = false;

   454   }

   455 

   456   private void verifye_c_array_e_ulong(int discriminator)

   457   {

   458     if (discriminator != 20)

   459       throw new org.omg.CORBA.BAD_OPERATION();

   460   }

   461 

   462   public float[] e_c_array_e_float()

   463   {

   464     if (__uninitialized)

   465       throw new org.omg.CORBA.BAD_OPERATION();

   466     verifye_c_array_e_float(__discriminator);

   467     return ___e_c_array_e_float;

   468   }

   469 

   470   public void e_c_array_e_float(float[] value)

   471   {

   472     __discriminator = 21;

   473     ___e_c_array_e_float = value;

   474     __uninitialized = false;

   475   }

   476 

   477   private void verifye_c_array_e_float(int discriminator)

   478   {

   479     if (discriminator != 21)

   480       throw new org.omg.CORBA.BAD_OPERATION();

   481   }

   482 

   483   public double[] e_c_array_e_double()

   484   {

   485     if (__uninitialized)

   486       throw new org.omg.CORBA.BAD_OPERATION();

   487     verifye_c_array_e_double(__discriminator);

   488     return ___e_c_array_e_double;

   489   }

   490 

   491   public void e_c_array_e_double(double[] value)

   492   {

   493     __discriminator = 22;

   494     ___e_c_array_e_double = value;

   495     __uninitialized = false;

   496   }

   497 

   498   private void verifye_c_array_e_double(int discriminator)

   499   {

   500     if (discriminator != 22)

   501       throw new org.omg.CORBA.BAD_OPERATION();

   502   }

   503 

   504   public char[] e_c_array_e_char()

   505   {

   506     if (__uninitialized)

   507       throw new org.omg.CORBA.BAD_OPERATION();

   508     verifye_c_array_e_char(__discriminator);

   509     return ___e_c_array_e_char;

   510   }

   511 

   512   public void e_c_array_e_char(char[] value)

   513   {

   514     __discriminator = 23;

   515     ___e_c_array_e_char = value;

   516     __uninitialized = false;

   517   }

   518 

   519   private void verifye_c_array_e_char(int discriminator)

   520   {

   521     if (discriminator != 23)

   522       throw new org.omg.CORBA.BAD_OPERATION();

   523   }

   524 

   525   public boolean[] e_c_array_e_boolean()

   526   {

   527     if (__uninitialized)

   528       throw new org.omg.CORBA.BAD_OPERATION();

   529     verifye_c_array_e_boolean(__discriminator);

   530     return ___e_c_array_e_boolean;

   531   }

   532 

   533   public void e_c_array_e_boolean(boolean[] value)

   534   {

   535     __discriminator = 24;

   536     ___e_c_array_e_boolean = value;

   537     __uninitialized = false;

   538   }

   539 

   540   private void verifye_c_array_e_boolean(int discriminator)

   541   {

   542     if (discriminator != 24)

   543       throw new org.omg.CORBA.BAD_OPERATION();

   544   }

   545 

   546   public byte[] e_c_array_e_octet()

   547   {

   548     if (__uninitialized)

   549       throw new org.omg.CORBA.BAD_OPERATION();

   550     verifye_c_array_e_octet(__discriminator);

   551     return ___e_c_array_e_octet;

   552   }

   553 

   554   public void e_c_array_e_octet(byte[] value)

   555   {

   556     __discriminator = 25;

   557     ___e_c_array_e_octet = value;

   558     __uninitialized = false;

   559   }

   560 

   561   private void verifye_c_array_e_octet(int discriminator)

   562   {

   563     if (discriminator != 25)

   564       throw new org.omg.CORBA.BAD_OPERATION();

   565   }

   566 

   567   public org.omg.CORBA.Any[] e_c_array_e_any()

   568   {

   569     if (__uninitialized)

   570       throw new org.omg.CORBA.BAD_OPERATION();

   571     verifye_c_array_e_any(__discriminator);

   572     return ___e_c_array_e_any;

   573   }

   574 

   575   public void e_c_array_e_any(org.omg.CORBA.Any[] value)

   576   {

   577     __discriminator = 26;

   578     ___e_c_array_e_any = value;

   579     __uninitialized = false;

   580   }

   581 

   582   private void verifye_c_array_e_any(int discriminator)

   583   {

   584     if (discriminator != 26)

   585       throw new org.omg.CORBA.BAD_OPERATION();

   586   }

   587 

   588   public String[] e_c_array_e_string()

   589   {

   590     if (__uninitialized)

   591       throw new org.omg.CORBA.BAD_OPERATION();

   592     verifye_c_array_e_string(__discriminator);

   593     return ___e_c_array_e_string;

   594   }

   595 

   596   public void e_c_array_e_string(String[] value)

   597   {

   598     __discriminator = 27;

   599     ___e_c_array_e_string = value;

   600     __uninitialized = false;

   601   }

   602 

   603   private void verifye_c_array_e_string(int discriminator)

   604   {

   605     if (discriminator != 27)

   606       throw new org.omg.CORBA.BAD_OPERATION();

   607   }

   608 

   609   public org.omg.CORBA.Object[] e_c_array_e_Object()

   610   {

   611     if (__uninitialized)

   612       throw new org.omg.CORBA.BAD_OPERATION();

   613     verifye_c_array_e_Object(__discriminator);

   614     return ___e_c_array_e_Object;

   615   }

   616 

   617   public void e_c_array_e_Object(org.omg.CORBA.Object[] value)

   618   {

   619     __discriminator = 28;

   620     ___e_c_array_e_Object = value;

   621     __uninitialized = false;

   622   }

   623 

   624   private void verifye_c_array_e_Object(int discriminator)

   625   {

   626     if (discriminator != 28)

   627       throw new org.omg.CORBA.BAD_OPERATION();

   628   }

   629 

   630   public void _default()

   631   {

   632     __discriminator = -2147483648;

   633     __uninitialized = false;

   634   }

   635 } // class F_union