Source for gnu.CORBA.HolderLocator

   1: /* HolderLocator.java --
   2:    Copyright (C) 2005 Free Software Foundation, Inc.
   3: 
   4: This file is part of GNU Classpath.
   5: 
   6: GNU Classpath is free software; you can redistribute it and/or modify
   7: it under the terms of the GNU General Public License as published by
   8: the Free Software Foundation; either version 2, or (at your option)
   9: any later version.
  10: 
  11: GNU Classpath is distributed in the hope that it will be useful, but
  12: WITHOUT ANY WARRANTY; without even the implied warranty of
  13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14: General Public License for more details.
  15: 
  16: You should have received a copy of the GNU General Public License
  17: along with GNU Classpath; see the file COPYING.  If not, write to the
  18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19: 02110-1301 USA.
  20: 
  21: Linking this library statically or dynamically with other modules is
  22: making a combined work based on this library.  Thus, the terms and
  23: conditions of the GNU General Public License cover the whole
  24: combination.
  25: 
  26: As a special exception, the copyright holders of this library give you
  27: permission to link this library with independent modules to produce an
  28: executable, regardless of the license terms of these independent
  29: modules, and to copy and distribute the resulting executable under
  30: terms of your choice, provided that you also meet, for each linked
  31: independent module, the terms and conditions of the license of that
  32: module.  An independent module is a module which is not derived from
  33: or based on this library.  If you modify this library, you may extend
  34: this exception to your version of the library, but you are not
  35: obligated to do so.  If you do not wish to do so, delete this
  36: exception statement from your version. */
  37: 
  38: 
  39: package gnu.CORBA;
  40: 
  41: import org.omg.CORBA.AnyHolder;
  42: import org.omg.CORBA.AnySeqHolder;
  43: import org.omg.CORBA.BooleanHolder;
  44: import org.omg.CORBA.BooleanSeqHolder;
  45: import org.omg.CORBA.CharHolder;
  46: import org.omg.CORBA.CharSeqHolder;
  47: import org.omg.CORBA.DoubleHolder;
  48: import org.omg.CORBA.DoubleSeqHolder;
  49: import org.omg.CORBA.FixedHolder;
  50: import org.omg.CORBA.FloatHolder;
  51: import org.omg.CORBA.FloatSeqHolder;
  52: import org.omg.CORBA.IntHolder;
  53: import org.omg.CORBA.LongHolder;
  54: import org.omg.CORBA.LongLongSeqHolder;
  55: import org.omg.CORBA.LongSeqHolder;
  56: import org.omg.CORBA.OctetSeqHolder;
  57: import org.omg.CORBA.PrincipalHolder;
  58: import org.omg.CORBA.ShortHolder;
  59: import org.omg.CORBA.ShortSeqHolder;
  60: import org.omg.CORBA.StringHolder;
  61: import org.omg.CORBA.StringSeqHolder;
  62: import org.omg.CORBA.TCKind;
  63: import org.omg.CORBA.TypeCode;
  64: import org.omg.CORBA.TypeCodeHolder;
  65: import org.omg.CORBA.ULongLongSeqHolder;
  66: import org.omg.CORBA.ULongSeqHolder;
  67: import org.omg.CORBA.UShortSeqHolder;
  68: import org.omg.CORBA.WCharSeqHolder;
  69: import org.omg.CORBA.WStringSeqHolder;
  70: import org.omg.CORBA.portable.Streamable;
  71: import org.omg.CORBA.ObjectHolder;
  72: 
  73: /**
  74:  * Creates the suitable holder for storing the value of the given final_type.
  75:  *
  76:  * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
  77:  */
  78: public class HolderLocator
  79: {
  80:   /**
  81:    * The array, sufficiently large to use any {@link TCKind}._tk* constant as
  82:    * an index.
  83:    */
  84:   private static final Class[] holders;
  85: 
  86:   private static final Class[] seqHolders;
  87: 
  88:   static
  89:     {
  90:       holders = new Class[32];
  91:       holders[TCKind._tk_Principal] = PrincipalHolder.class;
  92:       holders[TCKind._tk_TypeCode] = TypeCodeHolder.class;
  93:       holders[TCKind._tk_any] = AnyHolder.class;
  94:       holders[TCKind._tk_boolean] = BooleanHolder.class;
  95:       holders[TCKind._tk_char] = CharHolder.class;
  96:       holders[TCKind._tk_double] = DoubleHolder.class;
  97:       holders[TCKind._tk_float] = FloatHolder.class;
  98:       holders[TCKind._tk_fixed] = FixedHolder.class;
  99:       holders[TCKind._tk_long] = IntHolder.class;
 100:       holders[TCKind._tk_longdouble] = DoubleHolder.class;
 101:       holders[TCKind._tk_longlong] = LongHolder.class;
 102:       holders[TCKind._tk_octet] = OctetHolder.class;
 103:       holders[TCKind._tk_short] = ShortHolder.class;
 104:       holders[TCKind._tk_string] = StringHolder.class;
 105:       holders[TCKind._tk_ulong] = IntHolder.class;
 106:       holders[TCKind._tk_ulonglong] = LongHolder.class;
 107:       holders[TCKind._tk_ushort] = ShortHolder.class;
 108:       holders[TCKind._tk_wchar] = WCharHolder.class;
 109:       holders[TCKind._tk_wstring] = WStringHolder.class;
 110:       holders[TCKind._tk_objref] = ObjectHolder.class;
 111: 
 112:       seqHolders = new Class[32];
 113: 
 114:       seqHolders[TCKind._tk_ulonglong] = ULongLongSeqHolder.class;
 115:       seqHolders[TCKind._tk_short] = ShortSeqHolder.class;
 116:       seqHolders[TCKind._tk_octet] = OctetSeqHolder.class;
 117:       seqHolders[TCKind._tk_any] = AnySeqHolder.class;
 118:       seqHolders[TCKind._tk_long] = LongSeqHolder.class;
 119:       seqHolders[TCKind._tk_longlong] = LongLongSeqHolder.class;
 120:       seqHolders[TCKind._tk_float] = FloatSeqHolder.class;
 121:       seqHolders[TCKind._tk_double] = DoubleSeqHolder.class;
 122:       seqHolders[TCKind._tk_char] = CharSeqHolder.class;
 123:       seqHolders[TCKind._tk_boolean] = BooleanSeqHolder.class;
 124:       seqHolders[TCKind._tk_wchar] = WCharSeqHolder.class;
 125:       seqHolders[TCKind._tk_ushort] = UShortSeqHolder.class;
 126:       seqHolders[TCKind._tk_ulong] = ULongSeqHolder.class;
 127:       seqHolders[TCKind._tk_string] = StringSeqHolder.class;
 128:       seqHolders[TCKind._tk_wstring] = WStringSeqHolder.class;
 129:     }
 130: 
 131:   /**
 132:    * Create a holder for storing the value of the given built-in final_type. This
 133:    * function returns the defined holders for the built-in primitive types and
 134:    * they sequences.
 135:    *
 136:    * @param t the typecode
 137:    *
 138:    * @return an instance of the corresponding built-in holder of null if no such
 139:    * is defined for this final_type. The holder is created with a parameterless
 140:    * constructor.
 141:    */
 142:   public static Streamable createHolder(TypeCode t)
 143:   {
 144:     try
 145:       {
 146:         int kind = t.kind().value();
 147:         int componentKind;
 148: 
 149:         Streamable holder = null;
 150: 
 151:         if (kind < holders.length && holders[kind] != null)
 152:           holder = (Streamable) holders[kind].newInstance();
 153: 
 154:         if (holder != null)
 155:           return holder;
 156: 
 157:         switch (kind)
 158:           {
 159:           case TCKind._tk_sequence:
 160:             componentKind = t.content_type().kind().value();
 161:             if (componentKind < seqHolders.length)
 162:               return (Streamable) seqHolders[componentKind].newInstance();
 163:             break;
 164: 
 165:           default:
 166:             break;
 167:           }
 168:       }
 169:     catch (Exception ex)
 170:       {
 171:         throw new Unexpected(ex);
 172:       }
 173: 
 174:     try
 175:       {
 176:         Object ox = ObjectCreator.createObject(t.id(), "Holder");
 177:         return (Streamable) ox;
 178:       }
 179:     catch (Exception ex)
 180:       {
 181:         return null;
 182:       }
 183:   }
 184: }