com.sun.tools.corba.se.idl.MethodEntry Java Examples

/**
 *
 **/
protected void localstub (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index, InterfaceEntry i)
{
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  this.methodIndex = index;
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print ("  public ");
  writeMethodSignature ();
  stream.println ();
  stream.println ("  {");
  writeLocalStubBody (i);
  stream.println ("  } // " + m.name ());
  stream.println ();
}
 

/**
 * Print the parameter list for the factory method.
 * @param m The method to list parameters for
 * @param listTypes If try, declare the parms, otherwise just list them
 * @param stream The PrintWriter to print on
 */
protected void writeParmList (MethodEntry m, boolean listTypes, PrintWriter stream) {
  boolean firstTime = true;
  Enumeration e = m.parameters ().elements ();
  while (e.hasMoreElements ())
  {
    if (firstTime)
      firstTime = false;
    else
      stream.print (", ");
    ParameterEntry parm = (ParameterEntry)e.nextElement ();
    if (listTypes) {
      writeParmType (parm.type (), parm.passType ());
      stream.print (' ');
    }
    // Print parm name
    stream.print (parm.name ());
    // end of parameter list
  }
}
 

/**
 *
 **/
protected void skeleton (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
{
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  this.methodIndex = index;
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print ("  public ");
  writeMethodSignature ();
  stream.println ();
  stream.println ("  {");
  writeSkeletonBody ();
  stream.println ("  } // " + m.name ());
}
 

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

/**
 *
 **/
protected void interfaceMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.interfaceMethod (symbolTable, a, stream);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.interfaceMethod (symbolTable, a, stream);
    clear ();
  }
}
 

/**
 *
 **/
protected void dispatchSkeleton (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.dispatchSkeleton (symbolTable, a, stream, index);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.dispatchSkeleton (symbolTable, m, stream, index + 1);
    clear ();
  }
}
 

/**
 * <d62023> - write a default factory method implementation for the
 *            <value>DefaultFactory. m is a methodEntry for a factory
 *            method contained in a non-abstract ValueEntry.
 **/
protected void defaultFactoryMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  String typeName = m.container (). name ();
  stream.println ();
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print   ("  public " + typeName + " " + m.name () + " (");
  writeParmList  (m, true, stream);
  stream.println (")");
  stream.println ("  {");
  stream.print   ("    return new " + typeName + "Impl (");
  writeParmList (m, false, stream);
  stream.println (");");
  stream.println ("  }");
}
 

/**
 *
 **/
protected void skeleton (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
{
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  this.methodIndex = index;
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print ("  public ");
  writeMethodSignature ();
  stream.println ();
  stream.println ("  {");
  writeSkeletonBody ();
  stream.println ("  } // " + m.name ());
}
 

/**
 *
 **/
protected void interfaceMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.interfaceMethod (symbolTable, a, stream);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.interfaceMethod (symbolTable, a, stream);
    clear ();
  }
}
 

/**
 *
 **/
protected void stub (String className, boolean isAbstract, Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.stub (className, isAbstract, symbolTable, a, stream, index);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.stub (className, isAbstract, symbolTable, a, stream, index + 1);
    clear ();
  }
}
 

/**
 *
 **/
protected void skeleton (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.skeleton (symbolTable, a, stream, index);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.skeleton (symbolTable, a, stream, index + 1);
    clear ();
  }
}
 

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

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

/**
 * <d62023> - write a default factory method implementation for the
 *            <value>DefaultFactory. m is a methodEntry for a factory
 *            method contained in a non-abstract ValueEntry.
 **/
protected void defaultFactoryMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  String typeName = m.container (). name ();
  stream.println ();
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print   ("  public " + typeName + " " + m.name () + " (");
  writeParmList  (m, true, stream);
  stream.println (")");
  stream.println ("  {");
  stream.print   ("    return new " + typeName + "Impl (");
  writeParmList (m, false, stream);
  stream.println (");");
  stream.println ("  }");
}
 

/**
 * <d62023-klr> Added for 2.4 RTF
 **/
protected void abstractMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.abstractMethod (symbolTable, a, stream);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.abstractMethod (symbolTable, a, stream);
    clear ();
  }
}
 

/**
 * Print the parameter list for the factory method.
 * @param m The method to list parameters for
 * @param listTypes If try, declare the parms, otherwise just list them
 * @param stream The PrintWriter to print on
 */
protected void writeParmList (MethodEntry m, boolean listTypes, PrintWriter stream) {
  boolean firstTime = true;
  Enumeration e = m.parameters ().elements ();
  while (e.hasMoreElements ())
  {
    if (firstTime)
      firstTime = false;
    else
      stream.print (", ");
    ParameterEntry parm = (ParameterEntry)e.nextElement ();
    if (listTypes) {
      writeParmType (parm.type (), parm.passType ());
      stream.print (' ');
    }
    // Print parm name
    stream.print (parm.name ());
    // end of parameter list
  }
}
 

/**
 * Print the parameter list for the factory method.
 * @param m The method to list parameters for
 * @param listTypes If try, declare the parms, otherwise just list them
 * @param stream The PrintWriter to print on
 */
protected void writeParmList (MethodEntry m, boolean listTypes, PrintWriter stream) {
  boolean firstTime = true;
  Enumeration e = m.parameters ().elements ();
  while (e.hasMoreElements ())
  {
    if (firstTime)
      firstTime = false;
    else
      stream.print (", ");
    ParameterEntry parm = (ParameterEntry)e.nextElement ();
    if (listTypes) {
      writeParmType (parm.type (), parm.passType ());
      stream.print (' ');
    }
    // Print parm name
    stream.print (parm.name ());
    // end of parameter list
  }
}
 

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

/**
 *
 **/
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 ();
        }
}
 

/**
 *
 **/
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 ();
}
 

/**
 *
 **/
protected void interfaceMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.interfaceMethod (symbolTable, a, stream);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.interfaceMethod (symbolTable, a, stream);
    clear ();
  }
}
 

/**
 *
 **/
protected void interfaceMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.interfaceMethod (symbolTable, a, stream);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.interfaceMethod (symbolTable, a, stream);
    clear ();
  }
}
 

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

/**
 * Print the parameter list for the factory method.
 * @param m The method to list parameters for
 * @param listTypes If try, declare the parms, otherwise just list them
 * @param stream The PrintWriter to print on
 */
protected void writeParmList (MethodEntry m, boolean listTypes, PrintWriter stream) {
  boolean firstTime = true;
  Enumeration e = m.parameters ().elements ();
  while (e.hasMoreElements ())
  {
    if (firstTime)
      firstTime = false;
    else
      stream.print (", ");
    ParameterEntry parm = (ParameterEntry)e.nextElement ();
    if (listTypes) {
      writeParmType (parm.type (), parm.passType ());
      stream.print (' ');
    }
    // Print parm name
    stream.print (parm.name ());
    // end of parameter list
  }
}
 

/**
 * <d62023> - write a default factory method implementation for the
 *            <value>DefaultFactory. m is a methodEntry for a factory
 *            method contained in a non-abstract ValueEntry.
 **/
protected void defaultFactoryMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  String typeName = m.container (). name ();
  stream.println ();
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print   ("  public " + typeName + " " + m.name () + " (");
  writeParmList  (m, true, stream);
  stream.println (")");
  stream.println ("  {");
  stream.print   ("    return new " + typeName + "Impl (");
  writeParmList (m, false, stream);
  stream.println (");");
  stream.println ("  }");
}
 

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

/**
 * <d62023> - write a default factory method implementation for the
 *            <value>DefaultFactory. m is a methodEntry for a factory
 *            method contained in a non-abstract ValueEntry.
 **/
protected void defaultFactoryMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
{
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  String typeName = m.container (). name ();
  stream.println ();
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print   ("  public " + typeName + " " + m.name () + " (");
  writeParmList  (m, true, stream);
  stream.println (")");
  stream.println ("  {");
  stream.print   ("    return new " + typeName + "Impl (");
  writeParmList (m, false, stream);
  stream.println (");");
  stream.println ("  }");
}
 

/**
 *
 **/
protected void localstub (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index, InterfaceEntry i)
{
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  this.methodIndex = index;
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print ("  public ");
  writeMethodSignature ();
  stream.println ();
  stream.println ("  {");
  writeLocalStubBody (i);
  stream.println ("  } // " + m.name ());
  stream.println ();
}
 

/**
 *
 **/
protected void stub (String className, boolean isAbstract,
    Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
{
  localOptimization =
      ((Arguments)Compile.compiler.arguments).LocalOptimization;
  this.isAbstract  = isAbstract;
  this.symbolTable = symbolTable;
  this.m           = m;
  this.stream      = stream;
  this.methodIndex = index;
  if (m.comment () != null)
    m.comment ().generate ("  ", stream);
  stream.print ("  public ");
  writeMethodSignature ();
  stream.println ();
  stream.println ("  {");
  writeStubBody ( className );
  stream.println ("  } // " + m.name ());
  stream.println ();
}
 

/**
 *
 **/
protected void skeleton (Hashtable symbolTable, MethodEntry m, PrintWriter stream, int index)
{
  AttributeEntry a = (AttributeEntry)m;

  // Generate for the get method
  super.skeleton (symbolTable, a, stream, index);

  // Generate for the set method if the attribute is not readonly
  if (!a.readOnly ())
  {
    setupForSetMethod ();
    super.skeleton (symbolTable, a, stream, index + 1);
    clear ();
  }
}