jdk8-mips64-public/corba: src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/ValueGen.java@6845b95cba6b (annotated)

src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/ValueGen.java@6845b95cba6b (annotated)

src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/ValueGen.java

Thu, 31 Aug 2017 18:10:36 +0800

author: aoqi
date: Thu, 31 Aug 2017 18:10:36 +0800
changeset 748: 6845b95cba6b
parent 158: 91006f157c46
parent 0: 7ef37b2cdcad
permissions: -rw-r--r--

merge

 /*
  * 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

Mercurial > jdk8-mips64-public > corba / annotate

src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/ValueGen.java@6845b95cba6b (annotated)

src/share/classes/com/sun/tools/corba/se/idl/toJavaPortable/ValueGen.java