Java example source code file (Skeleton.java)

This example Java source code file (Skeleton.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

attributeentry, concrete, constructors, corba\:\:object, enumeration, hashtable, interfaceentry, methodentry, namemodifier, operations, skeleton, string, util, valueentry, vector

The Skeleton.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.
// -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