1) Fixed the parser problem with the '::' (Paamayim Nekudotayim).
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / ui / CodeGeneration.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2004 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.ui;
12
13 import net.sourceforge.phpdt.core.ICompilationUnit;
14 import net.sourceforge.phpdt.core.IMethod;
15 import net.sourceforge.phpdt.internal.corext.codemanipulation.StubUtility;
16
17 import org.eclipse.core.runtime.CoreException;
18
19 /**
20  * Class that offers access to the templates contained in the 'code templates'
21  * preference page.
22  * 
23  * @since 2.1
24  */
25 public class CodeGeneration {
26
27         private CodeGeneration() {
28         }
29
30         /**
31          * Returns the content for a new compilation unit using the 'new Java file'
32          * code template.
33          * 
34          * @param cu
35          *            The compilation to create the source for. The compilation unit
36          *            does not need to exist.
37          * @param typeComment
38          *            The comment for the type to be created. Used when the code
39          *            template contains a <i>${typecomment}</i> variable. Can be
40          *            <code>null</code> if no comment should be added.
41          * @param typeContent
42          *            The code of the type, including type declaration and body.
43          * @param lineDelimiter
44          *            The line delimiter to be used.
45          * @return Returns the new content or <code>null</code> if the template is
46          *         undefined or empty.
47          * @throws CoreException
48          *             Thrown when the evaluation of the code template fails.
49          */
50 //      public static String getCompilationUnitContent(ICompilationUnit cu,
51 //                      String typeComment, String typeContent, String lineDelimiter)
52 //                      throws CoreException {
53 //              return StubUtility.getCompilationUnitContent(cu, typeComment,
54 //                              typeContent, lineDelimiter);
55 //      }
56
57         /**
58          * Returns the content for a new type comment using the 'type comment' code
59          * template. The returned content is unformatted and is not indented.
60          * 
61          * @param cu
62          *            The compilation where the type is contained. The compilation
63          *            unit does not need to exist.
64          * @param typeQualifiedName
65          *            The name of the type to which the comment is added. For inner
66          *            types the name must be qualified and include the outer types
67          *            names (dot separated). See
68          *            {@link net.sourceforge.phpdt.core.IType#getTypeQualifiedName(char)}.
69          * @param lineDelimiter
70          *            The line delimiter to be used.
71          * @return Returns the new content or <code>null</code> if the code
72          *         template is undefined or empty. The returned content is
73          *         unformatted and is not indented.
74          * @throws CoreException
75          *             Thrown when the evaluation of the code template fails.
76          */
77         public static String getTypeComment(ICompilationUnit cu,
78                         String typeQualifiedName, String lineDelimiter)
79                         throws CoreException {
80                 return StubUtility.getTypeComment(cu, typeQualifiedName, lineDelimiter);
81         }
82
83         /**
84          * Returns the content for a new field comment using the 'field comment'
85          * code template. The returned content is unformatted and is not indented.
86          * 
87          * @param cu
88          *            The compilation where the field is contained. The compilation
89          *            unit does not need to exist.
90          * @param typeName
91          *            The name of the field declared type.
92          * @param fieldName
93          *            The name of the field to which the comment is added.
94          * @param lineDelimiter
95          *            The line delimiter to be used.
96          * @return Returns the new content or <code>null</code> if the code
97          *         template is undefined or empty. The returned content is
98          *         unformatted and is not indented.
99          * @throws CoreException
100          *             Thrown when the evaluation of the code template fails.
101          * @since 3.0
102          */
103 //      public static String getFieldComment(ICompilationUnit cu, String typeName,
104 //                      String fieldName, String lineDelimiter) throws CoreException {
105 //              return StubUtility.getFieldComment(cu, typeName, fieldName,
106 //                              lineDelimiter);
107 //      }
108
109         /**
110          * Returns the comment for a method or constructor using the comment code
111          * templates (constructor / method / overriding method). <code>null</code>
112          * is returned if the template is empty.
113          * 
114          * @param cu
115          *            The compilation unit to which the method belongs. The
116          *            compilation unit does not need to exist.
117          * @param declaringTypeName
118          *            Name of the type to which the method belongs. For inner types
119          *            the name must be qualified and include the outer types names
120          *            (dot separated). See
121          *            {@link net.sourceforge.phpdt.core.IType#getTypeQualifiedName(char)}.
122          * @param decl
123          *            The MethodDeclaration AST node that will be added as new
124          *            method. The node does not need to exist in an AST (no parent
125          *            needed) and does not need to resolve. See
126          *            {@link net.sourceforge.phpdt.core.dom.AST#newMethodDeclaration()}
127          *            for how to create such a node.
128          * @param overridden
129          *            The binding of the method that will be overridden by the
130          *            created method or <code>null</code> if no method is
131          *            overridden.
132          * @param lineDelimiter
133          *            The line delimiter to be used.
134          * @return Returns the generated method comment or <code>null</code> if
135          *         the code template is empty. The returned content is unformatted
136          *         and not indented (formatting required).
137          * @throws CoreException
138          *             Thrown when the evaluation of the code template fails.
139          */
140         // public static String getMethodComment(ICompilationUnit cu, String
141         // declaringTypeName, MethodDeclaration decl, IMethodBinding overridden,
142         // String lineDelimiter) throws CoreException {
143         // return StubUtility.getMethodComment(cu, declaringTypeName, decl,
144         // overridden, lineDelimiter);
145         // }
146         /**
147          * Returns the comment for a method or constructor using the comment code
148          * templates (constructor / method / overriding method). <code>null</code>
149          * is returned if the template is empty.
150          * <p>
151          * The returned string is unformatted and not indented.
152          * <p>
153          * Exception types and return type are in signature notation. e.g. a source
154          * method declared as <code>public void foo(String text, int length)</code>
155          * would return the array <code>{"QString;","I"}</code> as parameter
156          * types. See {@link net.sourceforge.phpdt.core.Signature}.
157          * 
158          * @param cu
159          *            The compilation unit to which the method belongs. The
160          *            compilation unit does not need to exist.
161          * @param declaringTypeName
162          *            Name of the type to which the method belongs. For inner types
163          *            the name must be qualified and include the outer types names
164          *            (dot separated). See
165          *            {@link net.sourceforge.phpdt.core.IType#getTypeQualifiedName(char)}.
166          * @param methodName
167          *            Name of the method.
168          * @param paramNames
169          *            Names of the parameters for the method.
170          * @param excTypeSig
171          *            Thrown exceptions (Signature notation).
172          * @param retTypeSig
173          *            Return type (Signature notation) or <code>null</code> for
174          *            constructors.
175          * @param overridden
176          *            The method that will be overridden by the created method or
177          *            <code>null</code> for non-overriding methods. If not
178          *            <code>null</code>, the method must exist.
179          * @param lineDelimiter
180          *            The line delimiter to be used.
181          * @return Returns the constructed comment or <code>null</code> if the
182          *         comment code template is empty. The returned content is
183          *         unformatted and not indented (formatting required).
184          * @throws CoreException
185          *             Thrown when the evaluation of the code template fails.
186          */
187         public static String getMethodComment(ICompilationUnit cu,
188                         String declaringTypeName, String methodName, String[] paramNames,
189                         String[] excTypeSig, String retTypeSig, IMethod overridden,
190                         String lineDelimiter) throws CoreException {
191                 return StubUtility.getMethodComment(cu, declaringTypeName, methodName,
192                                 paramNames, excTypeSig, retTypeSig, overridden, lineDelimiter);
193         }
194
195         /**
196          * Returns the comment for a method or constructor using the comment code
197          * templates (constructor / method / overriding method). <code>null</code>
198          * is returned if the template is empty.
199          * <p>
200          * The returned string is unformatted and not indented.
201          * 
202          * @param method
203          *            The method to be documented. The method must exist.
204          * @param overridden
205          *            The method that will be overridden by the created method or
206          *            <code>null</code> for non-overriding methods. If not
207          *            <code>null</code>, the method must exist.
208          * @param lineDelimiter
209          *            The line delimiter to be used.
210          * @return Returns the constructed comment or <code>null</code> if the
211          *         comment code template is empty. The returned string is
212          *         unformatted and and has no indent (formatting required).
213          * @throws CoreException
214          *             Thrown when the evaluation of the code template fails.
215          */
216         public static String getMethodComment(IMethod method, IMethod overridden,
217                         String lineDelimiter) throws CoreException {
218                 return StubUtility.getMethodComment(method, overridden, lineDelimiter);
219         }
220
221         /**
222          * Returns the content of the body for a method or constructor using the
223          * method body templates. <code>null</code> is returned if the template is
224          * empty.
225          * <p>
226          * The returned string is unformatted and not indented.
227          * 
228          * @param cu
229          *            The compilation unit to which the method belongs. The
230          *            compilation unit does not need to exist.
231          * @param declaringTypeName
232          *            Name of the type to which the method belongs. For inner types
233          *            the name must be qualified and include the outer types names
234          *            (dot separated). See
235          *            {@link net.sourceforge.phpdt.core.IType#getTypeQualifiedName(char)}.
236          * @param methodName
237          *            Name of the method.
238          * @param isConstructor
239          *            Defines if the created body is for a constructor.
240          * @param bodyStatement
241          *            The code to be entered at the place of the variable
242          *            ${body_statement}.
243          * @param lineDelimiter
244          *            The line delimiter to be used.
245          * @return Returns the constructed body content or <code>null</code> if
246          *         the comment code template is empty. The returned string is
247          *         unformatted and and has no indent (formatting required).
248          * @throws CoreException
249          *             Thrown when the evaluation of the code template fails.
250          */
251 //      public static String getMethodBodyContent(ICompilationUnit cu,
252 //                      String declaringTypeName, String methodName, boolean isConstructor,
253 //                      String bodyStatement, String lineDelimiter) throws CoreException {
254 //              return StubUtility.getMethodBodyContent(isConstructor, cu
255 //                              .getJavaProject(), declaringTypeName, methodName,
256 //                              bodyStatement, lineDelimiter);
257 //      }
258
259         /**
260          * Returns the content of body for a getter method using the getter method
261          * body template. <code>null</code> is returned if the template is empty.
262          * <p>
263          * The returned string is unformatted and not indented.
264          * 
265          * @param cu
266          *            The compilation unit to which the method belongs. The
267          *            compilation unit does not need to exist.
268          * @param declaringTypeName
269          *            Name of the type to which the method belongs. For inner types
270          *            the name must be qualified and include the outer types names
271          *            (dot separated). See
272          *            {@link net.sourceforge.phpdt.core.IType#getTypeQualifiedName(char)}.
273          * @param methodName
274          *            The name of the getter method.
275          * @param fieldName
276          *            The name of the field to get in the getter method,
277          *            corresponding to the template variable for ${field}.
278          * @param lineDelimiter
279          *            The line delimiter to be used.
280          * @return Returns the constructed body content or <code>null</code> if
281          *         the comment code template is empty. The returned string is
282          *         unformatted and and has no indent (formatting required).
283          * @throws CoreException
284          *             Thrown when the evaluation of the code template fails.
285          * @since 3.0
286          */
287 //      public static String getGetterMethodBodyContent(ICompilationUnit cu,
288 //                      String declaringTypeName, String methodName, String fieldName,
289 //                      String lineDelimiter) throws CoreException {
290 //              return StubUtility.getGetterMethodBodyContent(cu.getJavaProject(),
291 //                              declaringTypeName, methodName, fieldName, lineDelimiter);
292 //      }
293
294         /**
295          * Returns the content of body for a setter method using the setter method
296          * body template. <code>null</code> is returned if the template is empty.
297          * <p>
298          * The returned string is unformatted and not indented.
299          * 
300          * @param cu
301          *            The compilation unit to which the method belongs. The
302          *            compilation unit does not need to exist.
303          * @param declaringTypeName
304          *            Name of the type to which the method belongs. For inner types
305          *            the name must be qualified and include the outer types names
306          *            (dot separated). See
307          *            {@link net.sourceforge.phpdt.core.IType#getTypeQualifiedName(char)}.
308          * @param methodName
309          *            The name of the setter method.
310          * @param fieldName
311          *            The name of the field to be set in the setter method,
312          *            corresponding to the template variable for ${field}.
313          * @param paramName
314          *            The name of the parameter passed to the setter method,
315          *            corresponding to the template variable for $(param).
316          * @param lineDelimiter
317          *            The line delimiter to be used.
318          * @return Returns the constructed body content or <code>null</code> if
319          *         the comment code template is empty. The returned string is
320          *         unformatted and and has no indent (formatting required).
321          * @throws CoreException
322          *             Thrown when the evaluation of the code template fails.
323          * @since 3.0
324          */
325 //      public static String getSetterMethodBodyContent(ICompilationUnit cu,
326 //                      String declaringTypeName, String methodName, String fieldName,
327 //                      String paramName, String lineDelimiter) throws CoreException {
328 //              return StubUtility.getSetterMethodBodyContent(cu.getJavaProject(),
329 //                              declaringTypeName, methodName, fieldName, paramName,
330 //                              lineDelimiter);
331 //      }
332
333         /**
334          * Returns the comment for a getter method using the getter comment
335          * template. <code>null</code> is returned if the template is empty.
336          * <p>
337          * The returned string is unformatted and not indented.
338          * 
339          * @param cu
340          *            The compilation unit to which the method belongs. The
341          *            compilation unit does not need to exist.
342          * @param declaringTypeName
343          *            Name of the type to which the method belongs. For inner types
344          *            the name must be qualified and include the outer types names
345          *            (dot separated). See
346          *            {@link net.sourceforge.phpdt.core.IType#getTypeQualifiedName(char)}.
347          * @param methodName
348          *            Name of the method.
349          * @param fieldName
350          *            Name of the field to get.
351          * @param fieldType
352          *            The type of the field to get.
353          * @param bareFieldName
354          *            The field name without prefix or suffix.
355          * @param lineDelimiter
356          *            The line delimiter to be used.
357          * @return Returns the generated getter comment or <code>null</code> if
358          *         the code template is empty. The returned content is not indented.
359          * @throws CoreException
360          *             Thrown when the evaluation of the code template fails.
361          * @since 3.0
362          */
363         public static String getGetterComment(ICompilationUnit cu,
364                         String declaringTypeName, String methodName, String fieldName,
365                         String fieldType, String bareFieldName, String lineDelimiter)
366                         throws CoreException {
367                 return StubUtility.getGetterComment(cu, declaringTypeName, methodName,
368                                 fieldName, fieldType, bareFieldName, lineDelimiter);
369         }
370
371         /**
372          * Returns the comment for a setter method using the setter method body
373          * template. <code>null</code> is returned if the template is empty.
374          * <p>
375          * The returned string is unformatted and not indented.
376          * 
377          * @param cu
378          *            The compilation unit to which the method belongs. The
379          *            compilation unit does not need to exist.
380          * @param declaringTypeName
381          *            Name of the type to which the method belongs. For inner types
382          *            the name must be qualified and include the outer types names
383          *            (dot separated). See
384          *            {@link net.sourceforge.phpdt.core.IType#getTypeQualifiedName(char)}.
385          * @param methodName
386          *            Name of the method.
387          * @param fieldName
388          *            Name of the field that is set.
389          * @param fieldType
390          *            The type of the field that is to set.
391          * @param paramName
392          *            The name of the parameter that used to set.
393          * @param bareFieldName
394          *            The field name without prefix or suffix.
395          * @param lineDelimiter
396          *            The line delimiter to be used.
397          * @return Returns the generated setter comment or <code>null</code> if
398          *         the code template is empty. The returned comment is not indented.
399          * @throws CoreException
400          *             Thrown when the evaluation of the code template fails.
401          * @since 3.0
402          */
403         public static String getSetterComment(ICompilationUnit cu,
404                         String declaringTypeName, String methodName, String fieldName,
405                         String fieldType, String paramName, String bareFieldName,
406                         String lineDelimiter) throws CoreException {
407                 return StubUtility.getSetterComment(cu, declaringTypeName, methodName,
408                                 fieldName, fieldType, paramName, bareFieldName, lineDelimiter);
409         }
410 }