Java example source code file (ValueGen.java)

This example Java source code file (ValueGen.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

enumeration, interfaceentry, interfacestate, methodentry, primitiveentry, printwriter, sequenceentry, string, stringentry, symtabentry, typedefentry, util, valueentry, valuegen, vector

The ValueGen.java Java example source code

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

    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>  
    }

    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