View Javadoc
1   /*
2    * Copyright (c) 1999, 2001, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  /*
26   * COMPONENT_NAME: idl.toJava
27   *
28   * ORIGINS: 27
29   *
30   * Licensed Materials - Property of IBM
31   * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999
32   * RMI-IIOP v1.0
33   *
34   */
35  
36  package com.sun.tools.corba.se.idl.toJavaPortable;
37  
38  // NOTES:
39  // -D62023   <klr> New file to implement CORBA 2.4 RTF
40  // -D62794   <klr> Fix problem with no-arg create functions
41  
42  import java.io.PrintWriter;
43  
44  import java.util.Enumeration;
45  import java.util.Vector;
46  import java.util.Hashtable;
47  
48  import com.sun.tools.corba.se.idl.GenFileStream;
49  import com.sun.tools.corba.se.idl.InterfaceEntry;
50  import com.sun.tools.corba.se.idl.MethodEntry;
51  import com.sun.tools.corba.se.idl.ParameterEntry;
52  import com.sun.tools.corba.se.idl.SymtabEntry;
53  import com.sun.tools.corba.se.idl.ValueEntry;
54  import com.sun.tools.corba.se.idl.ValueBoxEntry;
55  import com.sun.tools.corba.se.idl.TypedefEntry;
56  import com.sun.tools.corba.se.idl.InterfaceState;
57  import com.sun.tools.corba.se.idl.PrimitiveEntry;
58  import com.sun.tools.corba.se.idl.StructEntry;
59  
60  /**
61   *
62   **/
63  public class MethodGen24 extends MethodGen
64  {
65    /**
66     * Public zero-argument constructor.
67     **/
68    public MethodGen24 ()
69    {
70    } // ctor
71  
72    /**
73     * Print the parameter list for the factory method.
74     * @param m The method to list parameters for
75     * @param listTypes If try, declare the parms, otherwise just list them
76     * @param stream The PrintWriter to print on
77     */
78    protected void writeParmList (MethodEntry m, boolean listTypes, PrintWriter stream) {
79      boolean firstTime = true;
80      Enumeration e = m.parameters ().elements ();
81      while (e.hasMoreElements ())
82      {
83        if (firstTime)
84          firstTime = false;
85        else
86          stream.print (", ");
87        ParameterEntry parm = (ParameterEntry)e.nextElement ();
88        if (listTypes) {
89          writeParmType (parm.type (), parm.passType ());
90          stream.print (' ');
91        }
92        // Print parm name
93        stream.print (parm.name ());
94        // end of parameter list
95      }
96    }
97  
98    /**
99     * <d62023> Write the methodEntry for a valuetype factory method into
100    *          the Value Helper class. Contents from email from Simon,
101    *          4/25/99.
102    **/
103   protected void helperFactoryMethod (Hashtable symbolTable, MethodEntry m, SymtabEntry t, PrintWriter stream)
104   {
105     this.symbolTable = symbolTable;
106     this.m = m;
107     this.stream = stream;
108     String initializerName = m.name ();
109     String typeName = Util.javaName (t);
110     String factoryName = typeName + "ValueFactory";
111 
112     // Step 1. Print factory method decl up to parms.
113     stream.print  ("  public static " + typeName + " " + initializerName +
114             " (org.omg.CORBA.ORB $orb");
115     if (!m.parameters ().isEmpty ())
116       stream.print (", "); // <d62794>
117 
118     // Step 2. Print the declaration parameter list.
119     writeParmList (m, true, stream);
120 
121     // Step 3. Print the body of the factory method
122     stream.println (")");
123     stream.println ("  {");
124     stream.println ("    try {");
125     stream.println ("      " + factoryName + " $factory = (" + factoryName + ")");
126     stream.println ("          ((org.omg.CORBA_2_3.ORB) $orb).lookup_value_factory(id());");
127     stream.print   ("      return $factory." + initializerName + " (");
128     writeParmList (m, false, stream);
129     stream.println (");");
130     stream.println ("    } catch (ClassCastException $ex) {");
131     stream.println ("      throw new org.omg.CORBA.BAD_PARAM ();");
132     stream.println ("    }");
133     stream.println ("  }");
134     stream.println ();
135   } // helperFactoryMethod
136 
137   /**
138    * <d62023> - write an abstract method definition
139    **/
140   protected void abstractMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
141   {
142     this.symbolTable = symbolTable;
143     this.m           = m;
144     this.stream      = stream;
145     if (m.comment () != null)
146       m.comment ().generate ("  ", stream);
147     stream.print ("  ");
148     stream.print ("public abstract ");
149     writeMethodSignature ();
150     stream.println (";");
151     stream.println ();
152   } // abstractMethod
153 
154   /**
155    * <d62023> - write a default factory method implementation for the
156    *            <value>DefaultFactory. m is a methodEntry for a factory
157    *            method contained in a non-abstract ValueEntry.
158    **/
159   protected void defaultFactoryMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
160   {
161     this.symbolTable = symbolTable;
162     this.m           = m;
163     this.stream      = stream;
164     String typeName = m.container (). name ();
165     stream.println ();
166     if (m.comment () != null)
167       m.comment ().generate ("  ", stream);
168     stream.print   ("  public " + typeName + " " + m.name () + " (");
169     writeParmList  (m, true, stream);
170     stream.println (")");
171     stream.println ("  {");
172     stream.print   ("    return new " + typeName + "Impl (");
173     writeParmList (m, false, stream);
174     stream.println (");");
175     stream.println ("  }");
176   } // defaultFactoryMethod
177 
178   /**
179    * <d62023> - remove all valueInitializer junk
180    **/
181   protected void writeMethodSignature ()
182   {
183     // Step 0.  Print the return type and name.
184     // A return type of null indicates the "void" return type. If m is a
185     // Valuetype factory method, it has a null return type,
186     if (m.type () == null)
187     {
188         // if factory method, result type is container
189         if (isValueInitializer ())
190             stream.print (m.container ().name ());
191         else
192             stream.print ("void");
193     }
194     else
195     {
196       stream.print (Util.javaName (m.type ()));
197     }
198     stream.print (' ' + m.name () + " (");
199 
200     // Step 1.  Print the parameter list.
201     boolean firstTime = true;
202     Enumeration e = m.parameters ().elements ();
203     while (e.hasMoreElements ())
204     {
205       if (firstTime)
206         firstTime = false;
207       else
208         stream.print (", ");
209       ParameterEntry parm = (ParameterEntry)e.nextElement ();
210 
211       writeParmType (parm.type (), parm.passType ());
212 
213       // Print parm name
214       stream.print (' ' + parm.name ());
215     }
216 
217     // Step 2.  Add the context parameter if necessary.
218     if (m.contexts ().size () > 0)
219     {
220       if (!firstTime)
221         stream.print (", ");
222       stream.print ("org.omg.CORBA.Context $context");
223     }
224 
225     // Step 3.  Print the throws clause (if necessary).
226     if (m.exceptions ().size () > 0)
227     {
228       stream.print (") throws ");
229       e = m.exceptions ().elements ();
230       firstTime = true;
231       while (e.hasMoreElements ())
232       {
233         if (firstTime)
234           firstTime = false;
235         else
236           stream.print (", ");
237         stream.print (Util.javaName ((SymtabEntry)e.nextElement ()));
238       }
239     }
240     else
241       stream.print (')');
242   } // writeMethodSignature
243 
244   /**
245    * <d62023> - delete method templates for valuetypes
246    **/
247   protected void interfaceMethod (Hashtable symbolTable, MethodEntry m, PrintWriter stream)
248   {
249     this.symbolTable = symbolTable;
250     this.m           = m;
251     this.stream      = stream;
252     if (m.comment () != null)
253       m.comment ().generate ("  ", stream);
254     stream.print ("  ");
255     writeMethodSignature ();
256     stream.println (";");
257   } // interfaceMethod
258 }