private void writeIDLValue(Serializable object, String repID) { if (object instanceof StreamableValue) { ((StreamableValue)object)._write(parent); } else if (object instanceof CustomValue) { ((CustomValue)object).marshal(parent); } else { BoxedValueHelper helper = Utility.getHelper(object.getClass(), null, repID); boolean isCustom = false; if (helper instanceof ValueHelper && object instanceof CustomMarshal) { try { if (((ValueHelper)helper).get_type().type_modifier() == VM_CUSTOM.value) isCustom = true; } catch(BadKind ex) { throw wrapper.badTypecodeForCustomValue( CompletionStatus.COMPLETED_MAYBE, ex ) ; } } if (isCustom) ((CustomMarshal)object).marshal(parent); else helper.write_value(parent, object); } }
/** * Write the value base into the given stream, supplementing it with an array * of the provided repository ids plus the repository id, derived from the * passed value. * * @param output a stream to write to. * * @param value a value to write. * * @throws MARSHAL if the writing failed due any reason. */ public static void write(OutputStream output, Serializable value, String[] multiple_ids) { // Write null if this is a null value. if (value == null) output.write_long(vt_NULL); else { String[] ids = new String[multiple_ids.length + 1]; ids[0] = ObjectCreator.getRepositoryId(value.getClass()); System.arraycopy(multiple_ids, 0, ids, 1, multiple_ids.length); BoxedValueHelper h = getHelper(value.getClass(), ids); write_instance(output, value, ids, h); } }
/** * Write value (after header). */ static void writeValue(OutputStream output, Serializable value, BoxedValueHelper helper) { ((gnuValueStream) output).getRunTime().target = value; if (helper != null) helper.write_value(output, value); else if (!writeSelf(output, value)) { // Try to find helper via class loader. boolean ok = false; if (!ok) { if (output instanceof BufferedCdrOutput) { BufferedCdrOutput b = (BufferedCdrOutput) output; if (b.runtime == null) b.runtime = new gnuRuntime(null, value); } handler.writeValue(output, value); } } }
/** * Get the helper that could write the given object, or null if no pre-defined * helper available for this object. */ public static BoxedValueHelper getHelper(Class x, Object ids) { if (x != null && x.equals(String.class)) return m_StringValueHelper; else if (x != null && x.isArray()) return new ArrayValueHelper(x); else if (ids instanceof String) return locateHelper((String) ids); else if (ids instanceof String[]) { String[] ia = (String[]) ids; BoxedValueHelper h; for (int i = 0; i < ia.length; i++) { h = locateHelper(ia[i]); if (h != null) return h; } return null; } else return null; }
/** * Examines the valuetag to see how many (if any) repository IDs * are present on the wire. If no repository ID information * is on the wire but the expectedType or expectedTypeRepId * is known, it will return one of those (favoring the * expectedType's repId). Failing that, it uses the supplied * BoxedValueHelper to obtain the repository ID, as a last resort. */ private String readRepositoryIds(int valueTag, Class expectedType, String expectedTypeRepId, BoxedValueHelper factory) { switch(repIdUtil.getTypeInfo(valueTag)) { case RepositoryIdUtility.NO_TYPE_INFO : // Throw an exception if we have no repository ID info and // no expectedType to work with. Otherwise, how would we // know what to unmarshal? if (expectedType == null) { if (expectedTypeRepId != null) { return expectedTypeRepId; } else if (factory != null) { return factory.get_id(); } else { throw wrapper.expectedTypeNullAndNoRepId( CompletionStatus.COMPLETED_MAYBE); } } return repIdStrs.createForAnyType(expectedType); case RepositoryIdUtility.SINGLE_REP_TYPE_INFO : return read_repositoryId(); case RepositoryIdUtility.PARTIAL_LIST_TYPE_INFO : return read_repositoryIds(); default: throw wrapper.badValueTag( CompletionStatus.COMPLETED_MAYBE, Integer.toHexString(valueTag) ) ; } }
private java.lang.Object readIDLValue(int indirection, String repId, Class clazz, String codebase) { ValueFactory factory ; // Always try to find a ValueFactory first, as required by the spec. // There are some complications here in the IDL 3.0 mapping (see 1.13.8), // but basically we must always be able to override the DefaultFactory // or Helper mappings that are also used. This appears to be the case // even in the boxed value cases. The original code only did the lookup // in the case of class implementing either StreamableValue or CustomValue, // but abstract valuetypes only implement ValueBase, and really require // the use of the repId to find a factory (including the DefaultFactory). try { // use new-style OBV support (factory object) factory = Utility.getFactory(clazz, codebase, orb, repId); } catch (MARSHAL marshal) { // XXX log marshal at one of the INFO levels // Could not get a factory, so try alternatives if (!StreamableValue.class.isAssignableFrom(clazz) && !CustomValue.class.isAssignableFrom(clazz) && ValueBase.class.isAssignableFrom(clazz)) { // use old-style OBV support (helper object) BoxedValueHelper helper = Utility.getHelper(clazz, codebase, repId); if (helper instanceof ValueHelper) return readIDLValueWithHelper((ValueHelper)helper, indirection); else return helper.read_value(parent); } else { // must be a boxed IDLEntity, so make a reflective call to the // helper's static read method... return readBoxedIDLEntity(clazz, codebase); } } // If there was no error in getting the factory, use it. valueIndirection = indirection; // for callback return factory.read_value(parent); }
/** * Get the helper for an IDLValue * * Throws MARSHAL exception if no helper found. */ public static BoxedValueHelper getHelper(Class clazz, String codebase, String repId) { String className = null; if (clazz != null) { className = clazz.getName(); if (codebase == null) codebase = Util.getCodebase(clazz); } else { if (repId != null) className = RepositoryId.cache.getId(repId).getClassName(); if (className == null) // no repId or unrecognized repId throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE); } try { ClassLoader clazzLoader = (clazz == null ? null : clazz.getClassLoader()); Class helperClass = loadClassForClass(className+"Helper", codebase, clazzLoader, clazz, clazzLoader); return (BoxedValueHelper)helperClass.newInstance(); } catch (ClassNotFoundException cnfe) { throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE, cnfe ); } catch (IllegalAccessException iae) { throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE, iae ); } catch (InstantiationException ie) { throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE, ie ); } catch (ClassCastException cce) { throw wrapper.unableLocateValueHelper( CompletionStatus.COMPLETED_MAYBE, cce ); } }
/** * Tries to read using boxed value helper. */ public Serializable read_value(BoxedValueHelper helper) { if (subsequentCalls) return stream.read_value(helper); else { subsequentCalls = true; return helper.read_value(this); } }
/** * Write the value base into the given stream, stating that it is an instance * of the given class. * * @param output a stream to write to. * * @param value a value to write. * * @throws MARSHAL if the writing failed due any reason. */ public static void write(OutputStream output, Serializable value, Class substitute) { // Write null if this is a null value. if (value == null) output.write_long(vt_NULL); else if (value instanceof String || substitute == String.class) writeString(output, value); else { String vId = ObjectCreator.getRepositoryId(value.getClass()); if (substitute == null || value.getClass().equals(substitute)) write_instance(output, value, vId, getHelper(value.getClass(), vId)); else { String vC = ObjectCreator.getRepositoryId(substitute); String[] ids = new String[] { vId, vC }; BoxedValueHelper h = getHelper(substitute.getClass(), ids); // If the helper is available, it is also responsible for // providing the repository Id. Otherwise, write both // ids. if (h == null) write_instance(output, value, ids, null); else write_instance(output, value, h.get_id(), null); } } }
/** * Write standard value type header, followed by contents, produced by the * boxed value helper. * * @param output the stream to write to. * @param value the value to write, can be null. * @param helper the helper that writes the value content if it is not null * (must be provided for this method). */ public static void write(OutputStream output, Serializable value, BoxedValueHelper helper) { if (helper == null) throw new AssertionError("Helper must be provided"); if (value == null) output.write_long(vt_NULL); else write_instance(output, value, helper.get_id(), helper); }
