Source for gnu.CORBA.DynAn.AbstractAny

   1: /* AbstractAny.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.DynAn;
  40: 
  41: import gnu.CORBA.TypeKindNamer;
  42: 
  43: import org.omg.CORBA.Any;
  44: import org.omg.CORBA.LocalObject;
  45: import org.omg.CORBA.ORB;
  46: import org.omg.CORBA.TypeCode;
  47: import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
  48: 
  49: import java.io.Serializable;
  50: 
  51: /**
  52:  * The top of our DynAny implementation, this class provides ORB that is
  53:  * required to create anys and factory that is required to initialise DynAnys.
  54:  *
  55:  * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
  56:  */
  57: public abstract class AbstractAny
  58:   extends LocalObject
  59:   implements Serializable
  60: {
  61:   /**
  62:    * Use serialVersionUID for interoperability.
  63:    */
  64:   private static final long serialVersionUID = 1;
  65: 
  66:   /**
  67:    * The "initial final_type" that can be an alias of the known final_type.
  68:    */
  69:   public TypeCode official_type;
  70: 
  71:   /**
  72:    * The "basic" final_type to that the final_type finally evaluates.
  73:    */
  74:   public final TypeCode final_type;
  75: 
  76:   /**
  77:    * The DynAny factory, required in initializations.
  78:    */
  79:   public final gnuDynAnyFactory factory;
  80: 
  81:   /**
  82:    * The ORB, to that this DynAny belongs.
  83:    */
  84:   public final ORB orb;
  85: 
  86:   /**
  87:    * The minor code, indicating the error, related to work with non - GNU
  88:    * Classpath DynAny.
  89:    */
  90:   short MINOR = 8148;
  91: 
  92:   /**
  93:    * The message about the empty structure or exception.
  94:    */
  95:   static final String EMPTY = "Empty structure with no fields.";
  96: 
  97:   /**
  98:    * The message about the structure or exception size mismatch.
  99:    */
 100:   static final String SIZE = "Size mismatch.";
 101: 
 102:   /**
 103:    * The message about the content of this DynAny being equal to
 104:    * <code>null</code>
 105:    */
 106:   static final String ISNULL = "The content is null";
 107: 
 108:   /**
 109:    * The change value listener.
 110:    */
 111:   ValueChangeListener listener;
 112: 
 113:   /**
 114:    * Create the abstract dyn any.
 115:    */
 116:   public AbstractAny(TypeCode oType, TypeCode aType,
 117:                         gnuDynAnyFactory aFactory, ORB anOrb
 118:                        )
 119:   {
 120:     official_type = oType;
 121:     final_type = aType;
 122:     factory = aFactory;
 123:     orb = anOrb;
 124:   }
 125: 
 126:   /**
 127:    * Get the typecode.
 128:    */
 129:   public TypeCode type()
 130:   {
 131:     return official_type;
 132:   }
 133: 
 134:   /**
 135:    * Create the Any.
 136:    */
 137:   public Any createAny()
 138:   {
 139:     return orb.create_any();
 140:   }
 141: 
 142:   /**
 143:    * The "value changed" listener.
 144:    */
 145:   protected void valueChanged()
 146:   {
 147:     if (listener != null)
 148:       listener.changed();
 149:   }
 150: 
 151:   /**
 152:    * Check the type.
 153:    */
 154:   void checkType(TypeCode expected, TypeCode actual)
 155:           throws TypeMismatch
 156:   {
 157:     if (!expected.equal(actual))
 158:       throw new TypeMismatch(typeMismatch(expected, actual));
 159:   }
 160: 
 161:   /**
 162:    * Format "Type mismatch" string.
 163:    */
 164:   String typeMismatch(TypeCode expected, TypeCode actual)
 165:   {
 166:     return TypeKindNamer.nameIt(expected) + " expected " +
 167:            TypeKindNamer.nameIt(actual);
 168:   }
 169: 
 170:   /**
 171:    * Format "size mismatch" string.
 172:    */
 173:   String sizeMismatch(int here, int other)
 174:   {
 175:     return "Size mismatch, " + other + " (expected " + here + ")";
 176:   }
 177: }