| /* |
| * Copyright (c) 1999, 2001, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| /* |
| * COMPONENT_NAME: idl.toJava |
| * |
| * ORIGINS: 27 |
| * |
| * Licensed Materials - Property of IBM |
| * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999 |
| * RMI-IIOP v1.0 |
| * |
| */ |
| |
| package com.sun.tools.corba.se.idl.toJavaPortable; |
| |
| // NOTES: |
| // -F46082.51<daz> Remove -stateful feature; javaStatefulName() obsolete. |
| // -D57067 <klr> suppress default init if an emit init explicitly specified. |
| // -D59071 <daz> Clone method entries when their content needs modification. |
| // -D59092 <klr> Valuetype supporting interfaces should implement interface. |
| // -D59418 <klr> Custom values implement org.omg.CORBA.CustomMarshal |
| // -D59418 <klr> Invert read/read_Value, write/write_Value for Simon |
| // -D60929 <klr> Update for RTF2.4 changes |
| // -D62018 <klr> write_value for value with value field x calls xHelper.write. |
| // -D62062 <klr> Add _write to value Helper to marshal state. |
| // write_value for value subclass calls parent._write |
| // -D61650<daz> Remove '\n' from generated strings; use println()'s. |
| |
| import java.io.File; |
| import java.io.PrintWriter; |
| import java.util.Hashtable; |
| import java.util.Enumeration; |
| import java.util.Vector; |
| |
| import com.sun.tools.corba.se.idl.GenFileStream; |
| import com.sun.tools.corba.se.idl.InterfaceEntry; |
| import com.sun.tools.corba.se.idl.SymtabEntry; |
| import com.sun.tools.corba.se.idl.TypedefEntry; |
| import com.sun.tools.corba.se.idl.ValueEntry; |
| import com.sun.tools.corba.se.idl.ValueBoxEntry; |
| import com.sun.tools.corba.se.idl.InterfaceState; |
| import com.sun.tools.corba.se.idl.MethodEntry; |
| import com.sun.tools.corba.se.idl.PrimitiveEntry; |
| import com.sun.tools.corba.se.idl.SequenceEntry; |
| import com.sun.tools.corba.se.idl.StringEntry; |
| import com.sun.tools.corba.se.idl.StructEntry; |
| |
| /** |
| * |
| **/ |
| public class ValueGen implements com.sun.tools.corba.se.idl.ValueGen, JavaGenerator |
| { |
| /** |
| * Public zero-argument constructor. |
| **/ |
| public ValueGen () |
| { |
| } // ctor |
| |
| /** |
| * |
| **/ |
| public void generate (Hashtable symbolTable, ValueEntry v, PrintWriter str) |
| { |
| this.symbolTable = symbolTable; |
| this.v = v; |
| init (); |
| |
| openStream (); |
| if (stream == null) |
| return; |
| generateTie (); |
| generateHelper (); |
| generateHolder (); |
| writeHeading (); |
| writeBody (); |
| writeClosing (); |
| closeStream (); |
| } // generate |
| |
| /** |
| * Initialize members unique to this generator. |
| **/ |
| protected void init () |
| { |
| emit = ((Arguments)Compile.compiler.arguments).emit; |
| factories = (Factories)Compile.compiler.factories (); |
| } // init |
| |
| /** |
| * |
| **/ |
| protected void openStream () |
| { |
| stream = Util.stream (v, ".java"); |
| } // openStream |
| |
| /** |
| * Generate a Tie class only when the user specifies the TIE option |
| * and the valuetype does support an interface. |
| **/ |
| protected void generateTie () |
| { |
| boolean tie = ((Arguments)Compile.compiler.arguments).TIEServer; |
| if (v.supports ().size () > 0 && tie) |
| { |
| Factories factories = (Factories)Compile.compiler.factories (); |
| factories.skeleton ().generate (symbolTable, v); |
| } |
| } // generateTie |
| |
| /** |
| * |
| **/ |
| protected void generateHelper () |
| { |
| ((Factories)Compile.compiler.factories ()).helper ().generate (symbolTable, v); |
| } // generateHelper |
| |
| /** |
| * |
| **/ |
| protected void generateHolder () |
| { |
| ((Factories)Compile.compiler.factories ()).holder ().generate (symbolTable, v); |
| } // generateHolder |
| |
| /** |
| * |
| **/ |
| protected void writeHeading () |
| { |
| Util.writePackage (stream, v); |
| Util.writeProlog (stream, ((GenFileStream)stream).name ()); |
| |
| if (v.comment () != null) |
| v.comment ().generate ("", stream); |
| |
| if (v.isAbstract ()) |
| { |
| writeAbstract (); |
| return; |
| } |
| else |
| stream.print ("public class " + v.name ()); |
| |
| // There should always be at least one parent: ValueBase |
| SymtabEntry parent = (SymtabEntry) v.derivedFrom ().elementAt (0); |
| |
| // If parent is ValueBase, it's mapped to java.io.Serializable |
| String parentName = Util.javaName (parent); |
| boolean impl = false; |
| |
| if (parentName.equals ("java.io.Serializable")) |
| { |
| // stream.print (" implements org.omg.CORBA.portable.ValueBase, org.omg.CORBA.portable.Streamable"); |
| stream.print (" implements org.omg.CORBA.portable.ValueBase"); // <d60929> |
| impl = true; |
| } |
| else if ( !((ValueEntry)parent).isAbstract ()) |
| stream.print (" extends " + parentName); |
| |
| // if inheriting from abstract values |
| for (int i = 0; i < v.derivedFrom ().size (); i++) { |
| parent = (SymtabEntry) v.derivedFrom ().elementAt (i); |
| if ( ((ValueEntry)parent).isAbstract ()) |
| { |
| if (!impl) |
| { |
| stream.print (" implements "); |
| impl = true; |
| } |
| else |
| stream.print (", "); |
| stream.print (Util.javaName (parent)); |
| } |
| } |
| // <d59092-klr> Valuetype supporting interface implement Operations interface |
| // for supported IDL interface |
| if (((ValueEntry)v).supports ().size () > 0) { |
| if (!impl) |
| { |
| stream.print (" implements "); |
| impl = true; |
| } |
| else |
| stream.print (", "); |
| |
| InterfaceEntry s =(InterfaceEntry)((ValueEntry)v).supports().elementAt(0); |
| // abstract supported classes don't have "Operations" |
| if (s.isAbstract ()) |
| stream.print (Util.javaName (s)); |
| else |
| stream.print (Util.javaName (s) + "Operations"); |
| } |
| |
| // <d59418> Custom valuetypes implement org.omg.CORBA.CustomMarshal. |
| if ( ((ValueEntry)v).isCustom ()) { |
| if (!impl) |
| { |
| stream.print (" implements "); |
| impl = true; |
| } |
| else |
| stream.print (", "); |
| |
| stream.print ("org.omg.CORBA.CustomMarshal "); |
| } |
| |
| stream.println (); |
| stream.println ("{"); |
| } // writeHeading |
| |
| /** |
| * |
| **/ |
| protected void writeBody () |
| { |
| writeMembers (); |
| writeInitializers (); |
| writeConstructor (); // <d57067> |
| writeTruncatable (); // <d60929> |
| writeMethods (); |
| } // writeBody |
| |
| /** |
| * |
| **/ |
| protected void writeClosing () |
| { |
| if (v.isAbstract ()) |
| stream.println ("} // interface " + v.name ()); |
| else |
| stream.println ("} // class " + v.name ()); |
| } // writeClosing |
| |
| /** |
| * |
| **/ |
| protected void closeStream () |
| { |
| stream.close (); |
| } // closeStream |
| |
| /** |
| * |
| **/ |
| protected void writeConstructor () |
| { |
| // Per Simon, 9/3/98, emit a protected default constructor |
| if (!v.isAbstract () && !explicitDefaultInit) { // <d57067 - klr> |
| stream.println (" protected " + v.name () + " () {}"); |
| stream.println (); |
| } |
| } // writeConstructor |
| |
| /** |
| * |
| **/ |
| protected void writeTruncatable () // <d60929> |
| { |
| // Per Simon, 4/6/98, emit _truncatable_ids() |
| if (!v.isAbstract ()) { |
| stream.println (" public String[] _truncatable_ids() {"); |
| stream.println (" return " + Util.helperName(v, true) + ".get_instance().get_truncatable_base_ids();"); // <d61056> |
| stream.println (" }"); |
| stream.println (); |
| } |
| } // writeTruncatable |
| |
| /** |
| * |
| **/ |
| protected void writeMembers () |
| { |
| // if the value type contains no data members, a null return is expected |
| if (v.state () == null) |
| return; |
| |
| for (int i = 0; i < v.state ().size (); i ++) |
| { |
| InterfaceState member = (InterfaceState) v.state ().elementAt (i); |
| SymtabEntry entry = (SymtabEntry) member.entry; |
| Util.fillInfo (entry); |
| |
| if (entry.comment () != null) |
| entry.comment ().generate (" ", stream); |
| |
| String modifier = " "; |
| if (member.modifier == InterfaceState.Public) |
| modifier = " public "; |
| Util.writeInitializer (modifier, entry.name (), "", entry, stream); |
| } |
| } // writeMembers |
| |
| /** |
| * |
| **/ |
| protected void writeInitializers () |
| { |
| Vector init = v.initializers (); |
| if (init != null) |
| { |
| stream.println (); |
| for (int i = 0; i < init.size (); i++) |
| { |
| MethodEntry element = (MethodEntry) init.elementAt (i); |
| element.valueMethod (true); |
| ((MethodGen) element.generator ()). interfaceMethod (symbolTable, element, stream); |
| if (element.parameters ().isEmpty ()) // <d57067-klr> |
| explicitDefaultInit = true; |
| } |
| } |
| } // writeInitializers |
| |
| /** |
| * |
| **/ |
| protected void writeMethods () |
| { |
| // contained vector contains methods, attributes, const, enums, exceptions, |
| // structs, unions, or typedefs that are declared inside the value object. |
| // State members of the nested types are also included in this vector. |
| // Thus, if the declaration of a constructed type is nested in the decl. |
| // of a state member, e.g struct x {boolean b;} memberx; |
| // the generation of the nested type must be handled here. |
| Enumeration e = v.contained ().elements (); |
| while (e.hasMoreElements ()) |
| { |
| SymtabEntry contained = (SymtabEntry)e.nextElement (); |
| if (contained instanceof MethodEntry) |
| { |
| MethodEntry element = (MethodEntry)contained; |
| ((MethodGen)element.generator ()).interfaceMethod (symbolTable, element, stream); |
| } |
| else |
| { |
| // Generate the type referenced by the typedef. |
| if (contained instanceof TypedefEntry) |
| contained.type ().generate (symbolTable, stream); |
| |
| // Note that we also need to generate the typedef itself if |
| // contained is a typedef. |
| contained.generate (symbolTable, stream); |
| } |
| } |
| |
| // Abstract values are mapped to interfaces. There is no need to generate |
| // the bindings for inheriting methods in case of inheritance from other |
| // abstract values or supporting interface |
| if (v.isAbstract ()) |
| return; |
| |
| // workaround: if the value type doesnot support any interfaces, a null |
| // return is expected instead of an empty vector |
| |
| // if supporting an interfaces, generate bindings for inheriting methods |
| if (v.supports ().size () > 0) |
| { |
| InterfaceEntry intf = (InterfaceEntry) v.supports ().elementAt (0); |
| Enumeration el = intf.allMethods ().elements (); |
| while (el.hasMoreElements ()) |
| { |
| MethodEntry m = (MethodEntry) el.nextElement (); |
| // <d59071> Don't alter the symbol table/emit list elements! |
| //m.container (v); |
| //((MethodGen)m.generator ()).interfaceMethod (symbolTable, m, stream); |
| MethodEntry mClone = (MethodEntry)m.clone (); |
| mClone.container (v); |
| ((MethodGen)mClone.generator ()).interfaceMethod (symbolTable, mClone, stream); |
| } |
| } |
| |
| // if inheriting from abstract values, generating bindings for all |
| // inheriting methods |
| for (int i = 0; i < v.derivedFrom ().size (); i++) { |
| ValueEntry parentValue = (ValueEntry) v.derivedFrom ().elementAt (i); |
| if (parentValue.isAbstract ()) |
| { |
| Enumeration el = parentValue.allMethods ().elements (); |
| while (el.hasMoreElements ()) |
| { |
| MethodEntry m = (MethodEntry) el.nextElement (); |
| // <d59071> Don't alter the symbol table/emit list elements! |
| //m.container (v); |
| //((MethodGen)m.generator ()).interfaceMethod (symbolTable, m, stream); |
| MethodEntry mClone = (MethodEntry)m.clone (); |
| mClone.container (v); |
| ((MethodGen)mClone.generator ()).interfaceMethod (symbolTable, mClone, stream); |
| } |
| } |
| } |
| |
| //writeStreamableMethods (); |
| } // writeMethods |
| |
| /** |
| * |
| **/ |
| protected void writeStreamableMethods () |
| { |
| stream.println (" public void _read (org.omg.CORBA.portable.InputStream istream)"); |
| stream.println (" {"); |
| read (0, " ", "this", v, stream); |
| stream.println (" }"); |
| stream.println (); |
| stream.println (" public void _write (org.omg.CORBA.portable.OutputStream ostream)"); |
| stream.println (" {"); |
| write (0, " ", "this", v, stream); |
| stream.println (" }"); |
| stream.println (); |
| stream.println (" public org.omg.CORBA.TypeCode _type ()"); |
| stream.println (" {"); |
| stream.println (" return " + Util.helperName (v, false) + ".type ();"); // <d61056> |
| stream.println (" }"); |
| } // writeStreamableMethods |
| |
| /////////////// |
| // From JavaGenerator |
| |
| public int helperType (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream) |
| { |
| ValueEntry vt = (ValueEntry) entry; |
| Vector state = vt.state (); |
| int noOfMembers = state == null ? 0 : state.size (); |
| String members = "_members" + index++; |
| String tcOfMembers = "_tcOf" + members; |
| |
| stream.println (indent + "org.omg.CORBA.ValueMember[] " |
| + members + " = new org.omg.CORBA.ValueMember[" |
| + noOfMembers |
| + "];"); |
| stream.println (indent + "org.omg.CORBA.TypeCode " + tcOfMembers + " = null;"); |
| //stream.println (""); // <d61650> |
| |
| String definedInrepId = "_id"; |
| String repId, version; |
| |
| for (int k=0; k<noOfMembers; k++) |
| { |
| InterfaceState valueMember = (InterfaceState)state.elementAt (k); |
| TypedefEntry member = (TypedefEntry)valueMember.entry; |
| SymtabEntry mType = Util.typeOf (member); |
| if (hasRepId (member)) |
| { |
| repId = Util.helperName (mType, true) + ".id ()"; // <d61056> |
| if (mType instanceof ValueEntry || mType instanceof ValueBoxEntry) |
| // OBV spec is silent on defining VersionSpec for valuetype RepIds |
| version = "\"\""; |
| else |
| { |
| String id = mType.repositoryID ().ID (); |
| version = '"' + id.substring (id.lastIndexOf (':')+1) + '"'; |
| } |
| } |
| else |
| { |
| repId = "\"\""; |
| version = "\"\""; |
| } |
| |
| // Get TypeCode for valuetype member and store it var. name given by tcOfMembers |
| stream.println (indent + "// ValueMember instance for " + member.name ()); |
| index = ((JavaGenerator)member.generator ()).type (index, indent, tcoffsets, tcOfMembers, member, stream); |
| stream.println (indent + members + "[" + k + "] = new org.omg.CORBA.ValueMember (" // <d61650> |
| + '"' + member.name () + "\", "); // name |
| stream.println (indent + " " + repId + ", "); // id |
| stream.println (indent + " " + definedInrepId + ", "); // defined_in |
| stream.println (indent + " " + version + ", "); // version |
| stream.println (indent + " " + tcOfMembers + ", "); // type |
| stream.println (indent + " " + "null, "); // type_def |
| stream.println (indent + " " + "org.omg.CORBA." + |
| (valueMember.modifier == InterfaceState.Public ? |
| "PUBLIC_MEMBER" : "PRIVATE_MEMBER") + ".value" + ");"); // access |
| } // end for |
| |
| stream.println (indent + name + " = org.omg.CORBA.ORB.init ().create_value_tc (" |
| + "_id, " |
| + '"' + entry.name () + "\", " |
| + getValueModifier (vt) + ", " |
| + getConcreteBaseTypeCode (vt) + ", " |
| + members |
| + ");"); |
| |
| return index; |
| } // helperType |
| |
| public int type (int index, String indent, TCOffsets tcoffsets, String name, SymtabEntry entry, PrintWriter stream) { |
| stream.println (indent + name + " = " + Util.helperName (entry, true) + ".type ();"); // <d61056> |
| return index; |
| } // type |
| |
| // Check for types which don't have a Repository ID: primitive, |
| // string, arrays and sequences. |
| |
| private static boolean hasRepId (SymtabEntry member) |
| { |
| SymtabEntry mType = Util.typeOf (member); |
| return !( mType instanceof PrimitiveEntry || |
| mType instanceof StringEntry || |
| ( mType instanceof TypedefEntry && |
| !(((TypedefEntry)mType).arrayInfo ().isEmpty ()) ) || |
| ( mType instanceof TypedefEntry && member.type () instanceof SequenceEntry) ); |
| } // hasRepId |
| |
| private static String getValueModifier (ValueEntry vt) |
| { |
| String mod = "NONE"; |
| if (vt.isCustom ()) |
| mod = "CUSTOM"; |
| else if (vt.isAbstract ()) |
| mod = "ABSTRACT"; |
| else if (vt.isSafe ()) |
| mod = "TRUNCATABLE"; |
| return "org.omg.CORBA.VM_" + mod + ".value"; |
| } // getValueModifier |
| |
| private static String getConcreteBaseTypeCode (ValueEntry vt) |
| { |
| Vector v = vt.derivedFrom (); |
| if (!vt.isAbstract ()) |
| { |
| SymtabEntry base = (SymtabEntry)vt.derivedFrom ().elementAt (0); |
| if (!"ValueBase".equals (base.name ())) |
| return Util.helperName (base, true) + ".type ()"; // <d61056> |
| } |
| return "null"; |
| } // getConcreteBaseTypeCode |
| |
| public void helperRead (String entryName, SymtabEntry entry, PrintWriter stream) |
| { |
| // <d59418 - KLR> per Simon, make "static" read call istream.read_value. |
| // put real marshalling code in read_value. |
| |
| if (((ValueEntry)entry).isAbstract ()) |
| { |
| stream.println (" throw new org.omg.CORBA.BAD_OPERATION (\"abstract value cannot be instantiated\");"); |
| } |
| else |
| { |
| stream.println (" return (" + entryName +") ((org.omg.CORBA_2_3.portable.InputStream) istream).read_value (get_instance());"); // <d60929> |
| } |
| stream.println (" }"); |
| stream.println (); |
| |
| // done with "read", now do "read_value with real marshalling code. |
| |
| stream.println (" public java.io.Serializable read_value (org.omg.CORBA.portable.InputStream istream)"); // <d60929> |
| stream.println (" {"); |
| |
| // per Simon, 3/3/99, read_value for custom values throws an exception |
| if (((ValueEntry)entry).isAbstract ()) |
| { |
| stream.println (" throw new org.omg.CORBA.BAD_OPERATION (\"abstract value cannot be instantiated\");"); |
| } |
| else |
| if (((ValueEntry)entry).isCustom ()) |
| { |
| stream.println (" throw new org.omg.CORBA.BAD_OPERATION (\"custom values should use unmarshal()\");"); |
| } |
| else |
| { |
| stream.println (" " + entryName + " value = new " + entryName + " ();"); |
| read (0, " ", "value", entry, stream); |
| stream.println (" return value;"); |
| } |
| stream.println (" }"); |
| stream.println (); |
| // End of normal read method |
| |
| // Per Simon, 8/26/98 - Value helpers get an additional overloaded |
| // read method where the value is passed in instead of "new'd" up. This is |
| // used for reading parent value state. |
| |
| // Per Simon, 3/3/99 - Don't change this "read" for custom marshalling |
| stream.println (" public static void read (org.omg.CORBA.portable.InputStream istream, " + entryName + " value)"); |
| stream.println (" {"); |
| read (0, " ", "value", entry, stream); |
| } // helperRead |
| |
| public int read (int index, String indent, String name, SymtabEntry entry, PrintWriter stream) |
| { |
| // First do the state members from concrete parent hierarchy |
| Vector vParents = ((ValueEntry) entry).derivedFrom (); |
| if (vParents != null && vParents.size() != 0) |
| { |
| ValueEntry parent = (ValueEntry) vParents.elementAt (0); |
| if (parent == null) |
| return index; |
| // Per Simon, 4/6/99 - call parent read. <d60929> |
| if (! Util.javaQualifiedName(parent).equals ("java.io.Serializable")) // <d60929> |
| stream.println(indent + Util.helperName (parent, true) + ".read (istream, value);"); // <d60929> // <d61056> |
| } |
| |
| Vector vMembers = ((ValueEntry) entry).state (); |
| int noOfMembers = vMembers == null ? 0 : vMembers.size (); |
| |
| for (int k = 0; k < noOfMembers; k++) |
| { |
| TypedefEntry member = (TypedefEntry)((InterfaceState)vMembers.elementAt (k)).entry; |
| String memberName = member.name (); |
| SymtabEntry mType = member.type (); |
| |
| if (mType instanceof PrimitiveEntry || |
| mType instanceof TypedefEntry || |
| mType instanceof SequenceEntry || |
| mType instanceof StringEntry || |
| !member.arrayInfo ().isEmpty ()) |
| index = ((JavaGenerator)member.generator ()).read (index, indent, name + '.' + memberName, member, stream); |
| else if (mType instanceof ValueEntry) |
| { |
| String returnType = Util.javaQualifiedName (mType); |
| if (mType instanceof ValueBoxEntry) |
| // <f46082.51> Remove -stateful. |
| //returnType = Util.javaStatefulName (mType); |
| returnType = Util.javaName (mType); |
| stream.println (" " + name + '.' + memberName + " = (" + returnType + |
| ") ((org.omg.CORBA_2_3.portable.InputStream)istream).read_value (" + Util.helperName (mType, true) + // <d61056> |
| ".get_instance ());"); // <d61056> |
| } |
| else |
| stream.println (indent + name + '.' + memberName + " = " + |
| Util.helperName (mType, true) + ".read (istream);"); // <d61056> |
| } |
| |
| return index; |
| } // read |
| |
| public void helperWrite (SymtabEntry entry, PrintWriter stream) |
| { |
| // <d59418 - KLR> per Simon, make "static" write call istream.write_value. |
| // put real marshalling code in write_value. |
| stream.println (" ((org.omg.CORBA_2_3.portable.OutputStream) ostream).write_value (value, get_instance());"); // <d60929> |
| stream.println (" }"); |
| stream.println (); |
| |
| // <d62062> |
| // per Simon, 4/27/99, add static _write that marshals the state of this |
| // value for non-custom valuetypes |
| if (!((ValueEntry)entry).isCustom ()) |
| { |
| stream.println (" public static void _write (org.omg.CORBA.portable.OutputStream ostream, " + Util.javaName (entry) + " value)"); |
| stream.println (" {"); |
| write (0, " ", "value", entry, stream); |
| stream.println (" }"); |
| stream.println (); |
| } |
| |
| // done with "_write", now do "write_value |
| stream.println (" public void write_value (org.omg.CORBA.portable.OutputStream ostream, java.io.Serializable obj)"); // <d60929> |
| stream.println (" {"); |
| |
| // per Simon, 3/3/99, write_value for custom values throws an exception |
| if (((ValueEntry)entry).isCustom ()) |
| { |
| stream.println (" throw new org.omg.CORBA.BAD_OPERATION (\"custom values should use marshal()\");"); |
| } |
| else { |
| String entryName = Util.javaName(entry); |
| stream.println (" _write (ostream, (" + entryName + ") obj);"); // <d62062> |
| // write (0, " ", "value", entry, stream); <d62062> |
| } |
| } // helperWrite |
| |
| public int write (int index, String indent, String name, SymtabEntry entry, PrintWriter stream) |
| { |
| // First do the state members from concrete parent hierarchy |
| Vector vParents = ((ValueEntry)entry).derivedFrom (); |
| if (vParents != null && vParents.size () != 0) |
| { |
| ValueEntry parent = (ValueEntry)vParents.elementAt (0); |
| if (parent == null) |
| return index; |
| // Per Simon, 4/06/99 - call parent write. <d60929> |
| // Per Simon, 4/27/99 - call parent _write. <d62062> |
| if (! Util.javaQualifiedName(parent).equals ("java.io.Serializable")) // <d60929> |
| stream.println(indent + Util.helperName (parent, true) + "._write (ostream, value);"); // <d60929> <d61056> <d62062> |
| } |
| |
| Vector vMembers = ((ValueEntry) entry ).state (); |
| int noOfMembers = vMembers == null ? 0 : vMembers.size (); |
| for (int k = 0; k < noOfMembers; k++) |
| { |
| TypedefEntry member = (TypedefEntry)((InterfaceState)vMembers.elementAt (k)).entry; |
| String memberName = member.name (); |
| SymtabEntry mType = member.type (); |
| |
| if (mType instanceof PrimitiveEntry || |
| mType instanceof TypedefEntry || |
| mType instanceof SequenceEntry || |
| mType instanceof StringEntry || |
| !member.arrayInfo ().isEmpty ()) |
| index = ((JavaGenerator)member.generator ()).write (index, indent, name + '.' + memberName, member, stream); |
| else |
| stream.println (indent + Util.helperName (mType, true) + // <d61056> |
| ".write (ostream, " + name + '.' + memberName + ");"); |
| } |
| |
| return index; |
| } // write |
| |
| /** |
| * |
| **/ |
| protected void writeAbstract () |
| { |
| stream.print ("public interface " + v.name ()); |
| |
| // workaround: if the abstract value type does not have any parent, a vector |
| // containing ValueBase should be returned instead of an empty vector |
| if (v.derivedFrom ().size () == 0) |
| stream.print (" extends org.omg.CORBA.portable.ValueBase"); // <d60929> |
| else |
| { |
| SymtabEntry parent; |
| // list the values the abstract value type inherits |
| for (int i = 0; i < v.derivedFrom ().size (); i++) |
| { |
| if (i == 0) |
| stream.print (" extends "); |
| else |
| stream.print (", "); |
| parent = (SymtabEntry) v.derivedFrom ().elementAt (i); |
| stream.print (Util.javaName (parent)); |
| } |
| } |
| |
| // list the interface the abstract value type supports |
| if (v.supports ().size () > 0) |
| { |
| stream.print (", "); |
| SymtabEntry intf = (SymtabEntry) v.supports ().elementAt (0); |
| stream.print (Util.javaName (intf)); |
| } |
| stream.println (); |
| stream.println ("{"); |
| } |
| |
| protected int emit = 0; |
| protected Factories factories = null; |
| protected Hashtable symbolTable = null; |
| protected ValueEntry v = null; |
| protected PrintWriter stream = null; |
| protected boolean explicitDefaultInit = false; // <d57067 - klr> |
| } // class ValueGen |
