Source for gnu.CORBA.Minor

   1: /* Minor.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: 
  42: /**
  43:  * Provides information and operations, related to about the 20 bit vendor minor
  44:  * code Id. This code is included into all CORBA system exceptions and is also
  45:  * transferred to remote side.
  46:  *
  47:  * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
  48:  */
  49: public interface Minor
  50: {
  51:   // Note: MARSHAL done.
  52: 
  53:   /* MARSHAL */
  54: 
  55:   /**
  56:    * The GNU Classpath VMCID. The last 12 bits can be used to mark up to 4096
  57:    * possible exceptions.
  58:    */
  59:   int vendor = 0x47430000;
  60: 
  61:   /*
  62:    * Minor codes form MARSHAL exception.
  63:    */
  64: 
  65:   /**
  66:    * The message being received is not a GIOP message. It does not start from
  67:    * the expected magic sequence byte[] { 'G', 'I', 'O', 'P' }.
  68:    */
  69:   int Giop = 1 | vendor;
  70: 
  71:   /**
  72:    * The unexpected IOException while reading or writing the GIOP message header
  73:    * or the subsequent request or response header
  74:    */
  75:   int Header = 2 | vendor;
  76: 
  77:   /**
  78:    * The data stream ended before reading all expected values from it. This
  79:    * usually means that the CORBA message is corrupted, but may also indicate
  80:    * that the server expects the remote method being invoked to have more or
  81:    * different parameters.
  82:    */
  83:   int EOF = 3 | vendor;
  84: 
  85:   /**
  86:    * The unexpected IOException while reading or writing the data via Commond
  87:    * Data Representation stream.
  88:    */
  89:   int CDR = 5 | vendor;
  90: 
  91:   /**
  92:    * The unexpected IOException while reading or writing the Value type.
  93:    */
  94:   int Value = 6 | vendor;
  95: 
  96:   /**
  97:    * The unexpected IOException while handling request forwarding.
  98:    */
  99:   int Forwarding = 7 | vendor;
 100: 
 101:   /**
 102:    * The unexpected IOException while handling data encapsulation, tagged
 103:    * components, tagged profiles, etc.
 104:    */
 105:   int Encapsulation = 8 | vendor;
 106: 
 107:   /**
 108:    * The unexpected IOException while inserting or extracting data to/from the
 109:    * Any or DynamicAny.
 110:    */
 111:   int Any = 9 | vendor;
 112: 
 113:   /**
 114:    * The unexpected UserException in the context where it cannot be handled and
 115:    * must be converted to the SystemException.
 116:    */
 117:   int UserException = 10 | vendor;
 118: 
 119:   /**
 120:    * While the operation could formally be applied to the target, the OMG
 121:    * standard states that it is actually not applicable. For example, some CORBA
 122:    * objects like POA are always local and should not be passed to or returned
 123:    * from the remote side.
 124:    */
 125:   int Inappropriate = 11 | vendor;
 126: 
 127:   /**
 128:    * When reading data, it was discovered that size of the data structure like
 129:    * string, sequence or character is written as the negative number.
 130:    */
 131:   int Negative = 12 | vendor;
 132: 
 133:   /**
 134:    * Reference to non-existing node in the data grapth while reading the value
 135:    * types.
 136:    */
 137:   int Graph = 14 | vendor;
 138: 
 139:   /**
 140:    * Unexpected exception was thrown from the IDL type helper while handling the
 141:    * object of this type as a boxed value.
 142:    */
 143:   int Boxed = 15 | vendor;
 144: 
 145:   /**
 146:    * Unable to instantiate an value type object while reading it from the
 147:    * stream.
 148:    */
 149:   int Instantiation = 16 | vendor;
 150: 
 151:   /**
 152:    * The header tag of the value type being read from the CDR stream contains an
 153:    * unexpected value outside 0x7fffff00 .. 0x7fffffff and also not null and not
 154:    * an indirection.
 155:    */
 156:   int ValueHeaderTag = 17 | vendor;
 157: 
 158:   /**
 159:    * The header tag flags of the value type being read from the CDR stream make
 160:    * the invalid combination (for instance, 0x7fffff04).
 161:    */
 162:   int ValueHeaderFlags = 18 | vendor;
 163: 
 164:   /**
 165:    * The value type class, written on the wire, is not compatible with the
 166:    * expected class, passed as a parameter to the InputStream.read_value.
 167:    */
 168:   int ClassCast = 19 | vendor;
 169: 
 170:   /**
 171:    * Positive or otherwise invalid indirection offset when reading the data
 172:    * graph of the value type.
 173:    */
 174:   int Offset = 20 | vendor;
 175: 
 176:   /**
 177:    * Errors while reading the chunked value type.
 178:    */
 179:   int Chunks = 21 | vendor;
 180: 
 181:   /**
 182:    * No means are provided to write this value type.
 183:    */
 184:   int UnsupportedValue = 22 | vendor;
 185: 
 186:   /**
 187:    * The value factory, required for the operation being invoked, is not
 188:    * registered with this ORB.
 189:    */
 190:   int Factory = 23 | vendor;
 191: 
 192:   /**
 193:    * Unsupported object addressing method in GIOP request header.
 194:    */
 195:   int UnsupportedAddressing = 24 | vendor;
 196: 
 197:   /**
 198:    * Invalid stringified object reference (IOR).
 199:    */
 200:   int IOR = 25 | vendor;
 201: 
 202:   /**
 203:    * Problems with converting between stubs, ties, interfaces and
 204:    * implementations.
 205:    */
 206:   int TargetConversion = 26 | vendor;
 207: 
 208:   /**
 209:    * Problems with reading or writing the fields of the value type object.
 210:    */
 211:   int ValueFields = 27 | vendor;
 212: 
 213:   /**
 214:    * The instance of the value type is not serializable.
 215:    */
 216:   int NonSerializable = 28 | vendor;
 217: 
 218:   /* BAD_OPERATION */
 219: 
 220:   /**
 221:    * The remote side requested to invoke the method that is not available on
 222:    * that target (client and server probably disagree in the object definition).
 223:    */
 224:   int Method = 0 | vendor;
 225: 
 226:   /**
 227:    * Failed to activate the inactive object.
 228:    */
 229:   int Activation = 10 | vendor;
 230: 
 231:   /*
 232:    * Any - Attempt to extract from the Any value of the different type that was
 233:    * stored into that Any.
 234:    */
 235: 
 236:   /* ClassCast - Unable to narrow the object into stub. */
 237: 
 238:   /**
 239:    * The policies, applying to ORB or POA prevent the requested operation.
 240:    */
 241:   int Policy = 11 | vendor;
 242: 
 243:   /**
 244:    * Socket related errors like failure to open socket on the expected port,
 245:    * failure to get a free port when required and so on.
 246:    */
 247:   int Socket = 12 | vendor;
 248: 
 249:   /**
 250:    * The passed value for enumeration is outside the valid range for that
 251:    * enumeration.
 252:    */
 253:   int Enumeration = 14 | vendor;
 254: 
 255:   /**
 256:    * The passed policy code is outside the valid range of the possible policies
 257:    * for the given policy type.
 258:    */
 259:   int PolicyType = 15 | vendor;
 260: 
 261:   /* NO_RESOURCES */
 262: 
 263:   /**
 264:    * Unable to get a free port for a new socket. Proably too many objects under
 265:    * unsuitable POA policy.
 266:    */
 267:   int Ports = 20 | vendor;
 268: 
 269:   /**
 270:    * Too many parallel calls (too many parallel threads). The thread control
 271:    * prevents malicios client from knocking the server out by suddenly
 272:    * submitting large number of requests.
 273:    */
 274:   int Threads = 21 | vendor;
 275: 
 276:   /**
 277:    * The IOR starts with file://, http:// or ftp://, but this local or remote
 278:    * resource is not accessible.
 279:    */
 280:   int Missing_IOR = 22 | vendor;
 281: 
 282: }