idl/toJavaPortable/Skeleton.java

/*
 * 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.
// -D57147   <klr> Make _Tie implement org.omg.CORBA.portable.InvokeHandler
// -D58037   <klr> Make _Tie delegate to Operations interface
// -D62739   <klr> no TIE for values that support abstract interfaces, etc.

import java.io.File;
import java.io.PrintWriter;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import com.sun.tools.corba.se.idl.AttributeEntry;
import com.sun.tools.corba.se.idl.GenFileStream;

import com.sun.tools.corba.se.idl.InterfaceEntry;
import com.sun.tools.corba.se.idl.InterfaceState;
import com.sun.tools.corba.se.idl.MethodEntry;
import com.sun.tools.corba.se.idl.SymtabEntry;
import com.sun.tools.corba.se.idl.TypedefEntry;
import com.sun.tools.corba.se.idl.ValueEntry;

/**
 *
 **/
public class Skeleton implements AuxGen
{
  private NameModifier skeletonNameModifier ;
  private NameModifier tieNameModifier ;

  public Skeleton ()
  {
  }

  public void generate (Hashtable symbolTable, SymtabEntry entry)
  {
    // <d62739-begin>
    // Per Simon, 5-12-99, don't generate TIE or Skeleton for
    //
    // 1) valuetypes supporting abstract interfaces
    // 2) valuetypes with no supports.
    // 3) abstract interfaces
    //
    if (entry instanceof ValueEntry)
    {
      ValueEntry v = (ValueEntry) entry;
      if ((v.supports ().size () == 0) ||
          ((InterfaceEntry) v.supports ().elementAt (0)).isAbstract ()) {
        return;
        }
    }
    if (((InterfaceEntry) entry).isAbstract ()) {
        return;
    }
    // <d62739-end>

    this.symbolTable = symbolTable;

    this.i           = (InterfaceEntry)entry;
    init ();
    openStream ();
    if (stream == null)
      return;
    writeHeading ();
    writeBody ();
    writeClosing ();
    closeStream ();
  } // generate

  /**
   * Initialize members unique to this generator.
   **/
  protected void init ()
  {
    tie = ((Arguments)Compile.compiler.arguments).TIEServer ;
    poa = ((Arguments)Compile.compiler.arguments).POAServer ;

    skeletonNameModifier =
        ((Arguments)Compile.compiler.arguments).skeletonNameModifier ;
    tieNameModifier =
        ((Arguments)Compile.compiler.arguments).tieNameModifier ;

    tieClassName = tieNameModifier.makeName( i.name() ) ;
    skeletonClassName = skeletonNameModifier.makeName( i.name() ) ;

    intfName = Util.javaName (i);
    // for valuetype, get the name of the interface the valuetype supports
    if (i instanceof ValueEntry)
    {
      ValueEntry v = (ValueEntry) i;
      InterfaceEntry intf = (InterfaceEntry) v.supports ().elementAt (0);
      intfName = Util.javaName (intf);
    }
  } // init

  protected void openStream ()
  {
    if (tie)
        stream = Util.stream( i, tieNameModifier, ".java" ) ;
    else
        stream = Util.stream( i, skeletonNameModifier, ".java" ) ;
  } // openStream

  protected void writeHeading ()
  {
    Util.writePackage (stream, i, Util.StubFile);
    Util.writeProlog (stream, ((GenFileStream)stream).name ());
    if (i.comment () != null)
      i.comment ().generate ("", stream);
    writeClassDeclaration ();
    stream.println ('{');
    stream.println ();
  } // writeHeading

  protected void writeClassDeclaration ()
  {
    if (tie){
        stream.println ("public class " + tieClassName +
            " extends " + skeletonClassName ) ;
    } else {
        if (poa) {
            stream.println ("public abstract class " + skeletonClassName +
                            " extends org.omg.PortableServer.Servant");
            stream.print   (" implements " + intfName + "Operations, ");
            stream.println ("org.omg.CORBA.portable.InvokeHandler");
        } else {
            stream.println ("public abstract class " + skeletonClassName +
                            " extends org.omg.CORBA.portable.ObjectImpl");
            stream.print   ("                implements " + intfName + ", ");
            stream.println ("org.omg.CORBA.portable.InvokeHandler");
        }
    }
  } // writeClassDeclaration

  /**
   *
   **/
  protected void writeBody ()
  {
    // <f46082.51> Remove -stateful feature.  ?????
    //if (i.state () != null)
    //  writeState ();
    writeCtors ();
    if (i instanceof ValueEntry)
    {
      // use the interface the valuetype supports to generate the
      // tie class instead of using the valuetype itself
      ValueEntry v = (ValueEntry) i;
      this.i = (InterfaceEntry) v.supports ().elementAt (0);
    }
    buildMethodList ();
    //DispatchMethod and MethodTable
    if (tie){ //Concrete class implementing the remote interface
        //The logic is here for future use
        if (poa) {
            writeMethods ();
            stream.println ("  private " + intfName + "Operations _impl;");
            stream.println ("  private org.omg.PortableServer.POA _poa;");
        } else {
            writeMethods ();
            stream.println ("  private " + intfName + "Operations _impl;");
        }
    } else { //Both POA and ImplBase are abstract InvokeHandler
        //The logic is here for future use
        if (poa) {
            writeMethodTable ();
            writeDispatchMethod ();
            writeCORBAOperations ();
        } else {
            writeMethodTable ();
            writeDispatchMethod ();
            writeCORBAOperations ();
        }
    }
    //legacy !!
    writeOperations ();
  } // writeBody

  /**
   * Close the skeleton class. The singleton ORB member is
   * necessary only for portable skeletons.
   **/
  protected void writeClosing ()
  {
    stream.println ();
    if (tie){
        stream.println ("} // class " + tieClassName);
    } else {
        stream.println ("} // class " + skeletonClassName);
    }
  } // writeClosing

  /**
   * Close the print stream, which flushes the stream to file.
   **/
  protected void closeStream ()
  {
    stream.close ();
  } // closeStream

  protected void writeCtors ()
  {
    stream.println ("  // Constructors");
    // Empty argument constructors
    if (!poa) {
        if (tie){
            stream.println ("  public " + tieClassName + " ()");
            stream.println ("  {");
            stream.println ("  }");
        } else {
            stream.println ("  public " + skeletonClassName + " ()");
            stream.println ("  {");
            stream.println ("  }");
        }
    }
    stream.println ();
    // Argumented constructors
    if (tie){
        if (poa) {
            //Write constructors
            writePOATieCtors();
            //Write state setters and getters
            writePOATieFieldAccessMethods();
        } else {
            stream.println ("  public " + tieClassName +
                            " (" + intfName + "Operations impl)");
            stream.println ("  {");
            // Does it derive from a interface having state, e.g., valuetype?
            if (((InterfaceEntry)i.derivedFrom ().firstElement ()).state () != null)
                stream.println ("    super (impl);");
            else
                stream.println ("    super ();");
            stream.println ("    _impl = impl;");
            stream.println ("  }");
            stream.println ();
        }
    } else { //Skeleton is not Tie so it has no constructors.
        if (poa) {
        } else {
        }
    }

  } // writeCtors


  private void writePOATieCtors(){
    //First constructor
    stream.println ("  public " + tieClassName + " ( " + intfName + "Operations delegate ) {");
    stream.println ("      this._impl = delegate;");
    stream.println ("  }");
    //Second constructor specifying default poa.
    stream.println ("  public " + tieClassName + " ( " + intfName +
                    "Operations delegate , org.omg.PortableServer.POA poa ) {");
    stream.println ("      this._impl = delegate;");
    stream.println ("      this._poa      = poa;");
    stream.println ("  }");
  }

  private void writePOATieFieldAccessMethods(){
    //Getting delegate
    stream.println ("  public " + intfName+ "Operations _delegate() {");
    stream.println ("      return this._impl;");
    stream.println ("  }");
    //Setting delegate
    stream.println ("  public void _delegate (" + intfName + "Operations delegate ) {");
    stream.println ("      this._impl = delegate;");
    stream.println ("  }");
    //Overriding default poa
    stream.println ("  public org.omg.PortableServer.POA _default_POA() {");
    stream.println ("      if(_poa != null) {");
    stream.println ("          return _poa;");
    stream.println ("      }");
    stream.println ("      else {");
    stream.println ("          return super._default_POA();");
    stream.println ("      }");
    stream.println ("  }");
  }

  /**
   * Build a list of all of the methods, keeping out duplicates.
   **/
  protected void buildMethodList ()
  {
    // Start from scratch
    methodList = new Vector ();

    buildMethodList (i);
  } // buildMethodList

  /**
   *
   **/
  private void buildMethodList (InterfaceEntry entry)
  {
    // Add the local methods
    Enumeration locals = entry.methods ().elements ();
    while (locals.hasMoreElements ())
      addMethod ((MethodEntry)locals.nextElement ());

    // Add the inherited methods
    Enumeration parents = entry.derivedFrom ().elements ();
    while (parents.hasMoreElements ())
    {
      InterfaceEntry parent = (InterfaceEntry)parents.nextElement ();
      if (!parent.name ().equals ("Object"))
        buildMethodList (parent);
    }
  } // buildMethodList

  /**
   *
   **/
  private void addMethod (MethodEntry method)
  {
    if (!methodList.contains (method))
      methodList.addElement (method);
  } // addMethod

  /**
   *
   **/
  protected void writeDispatchMethod ()
  {
    String indent = "                                ";
    stream.println ("  public org.omg.CORBA.portable.OutputStream _invoke (String $method,");
    stream.println (indent + "org.omg.CORBA.portable.InputStream in,");
    stream.println (indent + "org.omg.CORBA.portable.ResponseHandler $rh)");
    stream.println ("  {");

    // this is a special case code generation for cases servantLocator and
    // servantActivator, where OMG is taking too long to define them
    // as local objects

    boolean isLocalInterface = false;
    if (i instanceof InterfaceEntry) {
        isLocalInterface = i.isLocalServant();
    }

    if (!isLocalInterface) {
        // Per Simon 8/26/98, create and return reply stream for all methods - KLR
        stream.println ("    org.omg.CORBA.portable.OutputStream out = null;");
        stream.println ("    java.lang.Integer __method = (java.lang.Integer)_methods.get ($method);");
        stream.println ("    if (__method == null)");
        stream.println ("      throw new org.omg.CORBA.BAD_OPERATION (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);");
        stream.println ();
        if (methodList.size () > 0)
        {
          stream.println ("    switch (__method.intValue ())");
          stream.println ("    {");

          // Write the method case statements
          int realI = 0;
          for (int i = 0; i < methodList.size (); ++i)
          {
            MethodEntry method = (MethodEntry)methodList.elementAt (i);
            ((MethodGen)method.generator ()).dispatchSkeleton (symbolTable, method, stream, realI);
            if (method instanceof AttributeEntry && !((AttributeEntry)method).readOnly ())
              realI += 2;
            else
              ++realI;
          }

          indent = "       ";
          stream.println (indent + "default:");
          stream.println (indent + "  throw new org.omg.CORBA.BAD_OPERATION (0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);");
          stream.println ("    }");
          stream.println ();
        }
        stream.println ("    return out;");
    } else {
        stream.println("    throw new org.omg.CORBA.BAD_OPERATION();");
    }
    stream.println ("  } // _invoke");
    stream.println ();
  } // writeDispatchMethod

  /**
   *
   **/
  protected void writeMethodTable ()
  {
    // Write the methods hashtable
    stream.println ("  private static java.util.Hashtable _methods = new java.util.Hashtable ();");
    stream.println ("  static");
    stream.println ("  {");

    int count = -1;
    Enumeration e = methodList.elements ();
    while (e.hasMoreElements ())
    {
      MethodEntry method = (MethodEntry)e.nextElement ();
      if (method instanceof AttributeEntry)
      {
        stream.println ("    _methods.put (\"_get_" + Util.stripLeadingUnderscores (method.name ()) + "\", new java.lang.Integer (" + (++count) + "));");
        if (!((AttributeEntry)method).readOnly ())
          stream.println ("    _methods.put (\"_set_" + Util.stripLeadingUnderscores (method.name ()) + "\", new java.lang.Integer (" + (++count) + "));");
      }
      else
        stream.println ("    _methods.put (\"" + Util.stripLeadingUnderscores (method.name ()) + "\", new java.lang.Integer (" + (++count) + "));");
    }
    stream.println ("  }");
    stream.println ();
  } // writeMethodTable

  /**
   *
   **/
  protected void writeMethods ()
  {
      int realI = 0;
      for (int i = 0; i < methodList.size (); ++i)
          {
              MethodEntry method = (MethodEntry)methodList.elementAt (i);
              ((MethodGen)method.generator ()).skeleton
                  (symbolTable, method, stream, realI);
              if (method instanceof AttributeEntry &&
                  !((AttributeEntry)method).readOnly ())
                  realI += 2;
              else
                  ++realI;
              stream.println ();
          }
  } // writeMethods

  /**
   *
   **/
  private void writeIDs ()
  {
    Vector list = new Vector ();
    buildIDList (i, list);
    Enumeration e = list.elements ();
    boolean first = true;
    while (e.hasMoreElements ())
    {
      if (first)
        first = false;
      else
        stream.println (", ");
      stream.print ("    \"" + (String)e.nextElement () + '"');
    }
  } // writeIDs

  /**
   *
   **/
  private void buildIDList (InterfaceEntry entry, Vector list)
  {
    if (!entry.fullName ().equals ("org/omg/CORBA/Object"))
    {
      String id = Util.stripLeadingUnderscoresFromID (entry.repositoryID ().ID ());
      if (!list.contains (id))
        list.addElement (id);
      Enumeration e = entry.derivedFrom ().elements ();
      while (e.hasMoreElements ())
        buildIDList ((InterfaceEntry)e.nextElement (), list);
    }
  } // buildIDList

  /**
   *
   **/
  protected void writeCORBAOperations ()
  {
    stream.println ("  // Type-specific CORBA::Object operations");

    stream.println ("  private static String[] __ids = {");
    writeIDs ();
    stream.println ("};");
    stream.println ();
    if (poa)
        writePOACORBAOperations();
    else
        writeNonPOACORBAOperations();

  } // writeCORBAOperations

  protected void writePOACORBAOperations(){
      stream.println ("  public String[] _all_interfaces (org.omg.PortableServer.POA poa, byte[] objectId)");
      //Right now, with our POA implementation, the same
      //implementation of _ids() type methods seem to work for both non-POA
      //as well as POA servers. We need to REVISIT since the equivalent
      //POA interface, i.e. _all_interfaces, has parameters which are not being
      //used in the _ids() implementation.
      stream.println ("  {");
      stream.println ("    return (String[])__ids.clone ();");
      stream.println ("  }");
      stream.println ();
      //_this()
      stream.println ("  public "+ i.name() +" _this() ");
      stream.println ("  {");
      stream.println ("    return "+ i.name() +"Helper.narrow(" );
      stream.println ("    super._this_object());");
      stream.println ("  }");
      stream.println ();
      //_this(org.omg.CORBA.ORB orb)
      stream.println ("  public "+ i.name() +" _this(org.omg.CORBA.ORB orb) ");
      stream.println ("  {");
      stream.println ("    return "+ i.name() +"Helper.narrow(" );
      stream.println ("    super._this_object(orb));");
      stream.println ("  }");
      stream.println ();
  }
  protected void writeNonPOACORBAOperations(){
      stream.println ("  public String[] _ids ()");
      stream.println ("  {");
      stream.println ("    return (String[])__ids.clone ();");
      stream.println ("  }");
      stream.println ();
  }
  /**
   *
   **/
  protected void writeOperations ()
  {
    // _get_ids removed at Simon's request 8/26/98 - KLR
  } // writeOperations

  protected Hashtable      symbolTable = null;
  protected InterfaceEntry i           = null;
  protected PrintWriter    stream      = null;

  // Unique to this generator
  protected String         tieClassName   = null;
  protected String         skeletonClassName   = null;
  protected boolean        tie         = false;
  protected boolean        poa         = false;
  protected Vector         methodList  = null;
  protected String         intfName    = "";
} // class Skeleton