Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
    *
    * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
    *
    * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
    * Other names may be trademarks of their respective owners.
    *
    * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common
   * Development and Distribution License("CDDL") (collectively, the
   * "License"). You may not use this file except in compliance with the
   * License. You can obtain a copy of the License at
   * http://www.netbeans.org/cddl-gplv2.html
   * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
   * specific language governing permissions and limitations under the
   * License.  When distributing the software, include this License Header
   * Notice in each file and include the License file at
   * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the GPL Version 2 section of the License file that
   * accompanied this code. If applicable, add the following below the
   * License Header, with the fields enclosed by brackets [] replaced by
   * your own identifying information:
   * "Portions Copyrighted [year] [name of copyright owner]"
   * 
   * Contributor(s):
   * 
   * The Original Software is NetBeans. The Initial Developer of the Original
   * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
   * Microsystems, Inc. All Rights Reserved.
   * 
   * If you wish your version of this file to be governed by only the CDDL
   * or only the GPL Version 2, indicate your decision by adding
   * "[Contributor] elects to include this software in this distribution
   * under the [CDDL or GPL Version 2] license." If you do not indicate a
   * single choice of license, a recipient has the option to distribute
   * your version of this file under either the CDDL, the GPL Version 2 or
   * to extend the choice of license to its licensees as provided above.
   * However, if you add GPL Version 2 code and therefore, elected the GPL
   * Version 2 license, then the option applies only if the new code is
   * made subject to such option by the copyright holder.
   */
  package org.netbeans.modules.websvc.saas.codegen.java.support;
  
  import java.util.List;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;

Author(s):
PeterLiu
 
 public class JavaSourceHelper {
 
     static final String CLASS_TEMPLATE = "Templates/Classes/Class.java"// NOI18N
     static final String INTERFACE_TEMPLATE = "Templates/Classes/Interface.java"// NOI18N
     static final String JAVA_EXT = "java"//NOI18N
 
     public static List<JavaSourcegetJavaSources(Project project) {
         List<JavaSourceresult = new ArrayList<JavaSource>();
         SourceGroup[] groups = SourceGroupSupport.getJavaSourceGroups(project);
 
         for (SourceGroup group : groups) {
             FileObject root = group.getRootFolder();
             Enumeration<? extends FileObjectfiles = root.getData(true);
 
             while (files.hasMoreElements()) {
                 FileObject fobj = files.nextElement();
 
                 if (fobj.getExt().equals()) {
                     JavaSource source = JavaSource.forFileObject(fobj);
                     result.add(source);
                 }
             }
         }
 
         return result;
     }
 
     public static List<JavaSourcegetEntityClasses(Project project) {
         List<JavaSourcesources = getJavaSources(project);
         List<JavaSourceentityClasses = new ArrayList<JavaSource>();
 
         for (JavaSource source : sources) {
             if (isEntity(source)) {
                 entityClasses.add(source);
             }
         }
 
         return entityClasses;
     }
 
     public static boolean isEntity(JavaSource source) {
         final boolean[] isBoolean = new boolean[1];
 
         try {
             source.runUserActionTask(new AbstractTask<CompilationController>() {
 
                 public void run(CompilationController controllerthrows IOException {
                     controller.toPhase(..);
 
                     TypeElement classElement = getTopLevelClassElement(controller);
                     if (classElement == null) {
                         return;
                     }
 
                     List<? extends AnnotationMirrorannotations = controller.getElements().getAllAnnotationMirrors(classElement);
 
                     for (AnnotationMirror annotation : annotations) {
                         if (annotation.toString().equals("@javax.persistence.Entity")) {
                             //NOI18N
                             isBoolean[0] = true;
 
                             break;
                         }
                     }
                 }
             }, true);
         } catch (IOException ex) {
         }
 
         return isBoolean[0];
     }

    

Parameters:
source
Returns:
 
     public static String getClassNameQuietly(JavaSource source) {
         try {
             return getClassName(source);
         } catch (IOException ioe) {
             Logger.getLogger(JavaSourceHelper.class.getName()).log(.ioe.getLocalizedMessage());
         }
         return null;
     }
 
     public static String getClassName(JavaSource sourcethrows IOException {
         return getTypeElement(source).getSimpleName().toString();
     }
 
     public static String getClassType(JavaSource sourcethrows IOException {
         return getTypeElement(source).getQualifiedName().toString();
     }
 
     public static String getPackageName(JavaSource source) {
         if(source == nullreturn "";
 
         final String[] packageName = new String[1];
         try {
             source.runUserActionTask(new AbstractTask<CompilationController>() {
 
                 public void run(CompilationController controllerthrows IOException {
                     controller.toPhase(..);
                     ExpressionTree packageTree = controller.getCompilationUnit().getPackageName();
                     if (packageTree != null) {
                         packageName[0] = packageTree.toString();
                     }
                 }
             }, true);
         } catch (IOException ex) {
         }
 
         return packageName[0];
     }
 
     public static String getIdFieldName(JavaSource source) {
         final String[] fieldName = new String[1];
 
         try {
             source.runUserActionTask(new AbstractTask<CompilationController>() {
 
                 public void run(CompilationController controllerthrows IOException {
                     controller.toPhase(..);
                     TypeElement classElement = getTopLevelClassElement(controller);
                     List<VariableElementfields = ElementFilter.fieldsIn(classElement.getEnclosedElements());
 
                     for (VariableElement field : fields) {
                         List<? extends AnnotationMirrorannotations = field.getAnnotationMirrors();
 
                         for (AnnotationMirror annotation : annotations) {
                             if (annotation.toString().equals("@javax.persistence.Id")) {
                                 //NOI18N
                                 fieldName[0] = field.getSimpleName().toString();
                                 return;
                             }
                         }
                     }
                 }
             }, true);
         } catch (IOException ex) {
         }
 
         return fieldName[0];
     }
 
     public static ClassTree getTopLevelClassTree(CompilationController controller) {
         String className = controller.getFileObject().getName();
 
         CompilationUnitTree cu = controller.getCompilationUnit();
         if (cu != null) {
             List<? extends Treedecls = cu.getTypeDecls();
             for (Tree decl : decls) {
                 if (!..contains(decl.getKind())) {
                     continue;
                 }
 
                 ClassTree classTree = (ClassTreedecl;
 
                 if (classTree.getSimpleName().contentEquals(className) && classTree.getModifiers().getFlags().contains(.)) {
                     return classTree;
                 }
             }
         }
         return null;
     }
 
     public static TypeElement getTopLevelClassElement(CompilationController controller) {
         ClassTree classTree = getTopLevelClassTree(controller);
         if (classTree == null) {
             return null;
         }
         Trees trees = controller.getTrees();
         TreePath path = trees.getPath(controller.getCompilationUnit(), classTree);
 
         return (TypeElementtrees.getElement(path);
     }
 
     public static Collection<StringgetImports(CompilationController controller) {
         Set<Stringimports = new HashSet<String>();
         CompilationUnitTree cu = controller.getCompilationUnit();
 
         if (cu != null) {
             List<? extends ImportTreeimportTrees = cu.getImports();
 
             for (ImportTree importTree : importTrees) {
                 imports.add(importTree.getQualifiedIdentifier().toString());
             }
         }
 
         return imports;
     }
 
     public static MethodTree getDefaultConstructor(CompilationController controller) {
         TypeElement classElement = getTopLevelClassElement(controller);
         List<ExecutableElementconstructors = ElementFilter.constructorsIn(classElement.getEnclosedElements());
 
         for (ExecutableElement constructor : constructors) {
             if (constructor.getParameters().size() == 0) {
                 return controller.getTrees().getTree(constructor);
             }
         }
 
         return null;
     }
 
     public static MethodTree getMethodByName(CompilationController controllerString methodName) {
         TypeElement classElement = getTopLevelClassElement(controller);
         List<ExecutableElementmethods = ElementFilter.methodsIn(classElement.getEnclosedElements());
         List<MethodTreefound = new ArrayList<MethodTree>();
         for (ExecutableElement method : methods) {
             if (method.getSimpleName().toString().equals(methodName)) {
                 found.add(controller.getTrees().getTree(method));
             }
         }
         if (found.size() > 1) {
             throw new IllegalArgumentException("Unexpected overloading methods of '" + methodName + "' found.");
         } else if (found.size() == 1) {
             return found.get(0);
         }
         return null;
     }
 
     public static VariableTree getField(CompilationController controllerString fieldName) {
         TypeElement classElement = getTopLevelClassElement(controller);
         List<VariableElementfields = ElementFilter.fieldsIn(classElement.getEnclosedElements());
 
         for (VariableElement field : fields) {
             if (field.getSimpleName().toString().equals(fieldName)) {
                 return (VariableTreecontroller.getTrees().getTree(field);
             }
         }
 
         return null;
     }
 
     public static JavaSource createJavaSource(FileObject targetFolderString packageNameString className) {
         return createJavaSource(targetFolderpackageNameclassName);
     }
 
     public static JavaSource createJavaSource(String templateFileObject targetFolderString packageNameString className) {
         try {
             FileObject fobj = targetFolder.getFileObject(className.);
             if (fobj == null) {
                 fobj = createDataObjectFromTemplate(templatetargetFolderpackageNameclassName).getPrimaryFile();
             }
             return JavaSource.forFileObject(fobj);
         } catch (IOException ex) {
             ErrorManager.getDefault().notify(.ex);
         }
 
         return null;
     }
 
     private static DataObject createDataObjectFromTemplate(String templateFileObject targetFolderString packageNameString targetNamethrows IOException {
         assert template != null;
         assert targetFolder != null;
         assert targetName != null && targetName.trim().length() > 0;
 
         FileObject templateFO = FileUtil.getConfigFile(template);
         DataObject templateDO = DataObject.find(templateFO);
         DataFolder dataFolder = DataFolder.findFolder(targetFolder);
 
         Map<StringStringparams = new HashMap<StringString>();
         params.put("package"packageName);
 
         return templateDO.createFromTemplate(dataFoldertargetNameparams);
     }
 
     public static void addClassAnnotation(WorkingCopy copyString[] annotationsObject[] annotationAttrs) {
         TreeMaker maker = copy.getTreeMaker();
         ClassTree tree = getTopLevelClassTree(copy);
 
         ModifiersTree modifiers = tree.getModifiers();
 
         for (int i = 0; i < annotations.lengthi++) {
             List<ExpressionTreeattrTrees = null;
             Object attr = annotationAttrs[i];
 
             if (attr != null) {
                 attrTrees = new ArrayList<ExpressionTree>();
 
                 if (attr instanceof ExpressionTree) {
                     attrTrees.add((ExpressionTreeattr);
                 } else {
                     attrTrees.add(maker.Literal(attr));
                 }
             } else {
                 attrTrees = Collections.<ExpressionTree>emptyList();
             }
 
             AnnotationTree newAnnotation = maker.Annotation(maker.Identifier(annotations[i]), attrTrees);
 
             if (modifiers != null) {
                 modifiers = maker.addModifiersAnnotation(modifiersnewAnnotation);
             }
         }
 
         copy.rewrite(tree.getModifiers(), modifiers);
     }
 
     public static void addImports(WorkingCopy copyString[] imports) {
         Collection<StringexistingImports = getImports(copy);
         TreeMaker maker = copy.getTreeMaker();
 
         CompilationUnitTree tree = copy.getCompilationUnit();
         CompilationUnitTree modifiedTree = tree;
 
         for (String imp : imports) {
             if (!existingImports.contains(imp)) {
                 modifiedTree = maker.addCompUnitImport(modifiedTreemaker.Import(maker.Identifier(imp), false));
             }
         }
 
         copy.rewrite(treemodifiedTree);
     }
 
     public static ClassTree addField(WorkingCopy copyClassTree treeModifier[] modifiersString[] annotationsObject[] annotationAttrsString nameObject type) {
         return addField(copytreemodifiersannotationsannotationAttrsnametypenull);
     }
 
     public static ClassTree addField(WorkingCopy copyClassTree treeModifier[] modifiersString[] annotationsObject[] annotationAttrsString nameObject typeObject initialValue) {
 
         TreeMaker maker = copy.getTreeMaker();
         ClassTree modifiedTree = tree;
 
         Tree typeTree = createTypeTree(copytype);
 
         ModifiersTree modifiersTree = createModifiersTree(copymodifiersannotationsannotationAttrs);
 
         ExpressionTree init = initialValue == null ? null : maker.Literal(initialValue);
 
         VariableTree variableTree = maker.Variable(modifiersTreenametypeTreeinit);
 
         return maker.insertClassMember(modifiedTree, 0, variableTree);
     }
 
     public static void addFields(WorkingCopy copyString[] namesObject[] types) {
         Object[] initValues = new Object[types.length];
         for (int i = 0; i < types.lengthi++) {
             Object type = types[i];
             if (String.class.equals(type) || String.class.getName().equals(type)) {
                 initValues[i] = "";
             } else if (type instanceof Class && Number.class.isAssignableFrom((Classtype)) {
                 initValues[i] = 0;
             } else {
                 initValues[i] = null;
             }
         }
         addFields(copynamestypesinitValues);
     }
 
     public static void addFields(WorkingCopy copyString[] namesObject[] typesObject[] initialValues) {
         addFields(copynamestypesinitialValues.);
     }
 
     public static void addConstants(WorkingCopy copyString[] namesObject[] typesObject[] initialValues) {
         addFields(copynamestypesinitialValues.);
     }
 
     public static void addFields(WorkingCopy copyString[] namesObject[] typesObject[] initialValuesModifier[] modifiers) {
 
         TreeMaker maker = copy.getTreeMaker();
         ClassTree classTree = getTopLevelClassTree(copy);
         ClassTree modifiedTree = classTree;
         String[] annotations = new String[0];
         Object[] annotationAttrs = new Object[0];
 
         for (int i = 0; i < names.lengthi++) {
             String name = names[i];
             Object type = types[i];
             Object initialValue = initialValues[i];
             // get around Retouche lack support for non-java.lang type Literal ???
             if (initialValue instanceof Enum) {
                 continue;
             }
 
             Tree typeTree = createTypeTree(copytype);
 
             ModifiersTree modifiersTree = createModifiersTree(copymodifiersannotationsannotationAttrs);
             ExpressionTree init = initialValue == null ? null : maker.Literal(initialValue);
             VariableTree variableTree = maker.Variable(modifiersTreenametypeTreeinit);
             modifiedTree = maker.insertClassMember(modifiedTree, 0, variableTree);
         }
         copy.rewrite(classTreemodifiedTree);
     }
 
     public static ClassTree addConstructor(WorkingCopy copyClassTree treeModifier[] modifiersString[] parametersObject[] paramTypesString bodyTextString comment) {
         TreeMaker maker = copy.getTreeMaker();
         ModifiersTree modifiersTree = createModifiersTree(copymodifiersnullnull);
         ModifiersTree paramModTree = maker.Modifiers(Collections.<Modifier>emptySet());
         List<VariableTreeparamTrees = new ArrayList<VariableTree>();
 
         if (parameters != null) {
             for (int i = 0; i < parameters.lengthi++) {
                 paramTrees.add(maker.Variable(paramModTreeparameters[i], createTypeTree(copyparamTypes[i]), null));
             }
         }
 
         MethodTree methodTree = maker.Constructor(modifiersTree, Collections.<TypeParameterTree>emptyList(), paramTrees, Collections.<ExpressionTree>emptyList(), bodyText);
 
         if (comment != null) {
             maker.addComment(methodTreecreateJavaDocComment(comment), true);
         }
 
         return maker.addClassMember(treemethodTree);
     }
 
     public static void replaceFieldValue(WorkingCopy copyVariableTree treeString value) {
         TreeMaker maker = copy.getTreeMaker();
 
         VariableTree modifiedTree = maker.Variable(tree.getModifiers(), tree.getName(), tree.getType(), maker.Literal(value));
 
         copy.rewrite(treemodifiedTree);
     }
 
     public static void replaceMethodBody(WorkingCopy copyMethodTree treeString body) {
         TreeMaker maker = copy.getTreeMaker();
         MethodTree modifiedTree = maker.Method(tree.getModifiers(), tree.getName(), tree.getReturnType(), tree.getTypeParameters(), tree.getParameters(), tree.getThrows(), bodynull);
 
         copy.rewrite(treemodifiedTree);
     }
 
     public static ClassTree addMethod(WorkingCopy copyClassTree treeModifier[] modifiersString[] annotationsObject[] annotationAttrsString nameObject returnTypeString[] parametersObject[] paramTypesObject[] paramAnnotationsArrayObject[] paramAnnotationAttrsArrayString bodyTextString comment) {
         return addMethod(copytreemodifiersannotationsannotationAttrsnamereturnTypeparametersparamTypesparamAnnotationsArrayparamAnnotationAttrsArraynullbodyTextcomment);
     }
 
     public static ClassTree addMethod(WorkingCopy copyClassTree treeModifier[] modifiersString[] annotationsObject[] annotationAttrsString nameObject returnTypeString[] parametersObject[] paramTypesObject[] paramAnnotationsArrayObject[] paramAnnotationAttrsArrayObject[] throwListString bodyTextString comment) {
         TreeMaker maker = copy.getTreeMaker();
         ModifiersTree modifiersTree = createModifiersTree(copymodifiersannotationsannotationAttrs);
 
         Tree returnTypeTree = createTypeTree(copyreturnType);
 
         List<VariableTreeparamTrees = new ArrayList<VariableTree>();
 
         if (parameters != null) {
             for (int i = 0; i < parameters.lengthi++) {
                 ModifiersTree paramModTree = maker.Modifiers(Collections.<Modifier>emptySet());
 
                 String[] paramAnnotations = null;
                 Object[] paramAnnotationAttrs = null;
 
                 if (paramAnnotationsArray != null && paramAnnotationsArray.length > 0) {
                     if (paramAnnotationsArray[iinstanceof String) {
                         paramAnnotations = new String[]{(StringparamAnnotationsArray[i]};
                         paramAnnotationAttrs = new Object[]{paramAnnotationAttrsArray[i]};
                     } else {
                         paramAnnotations = (String[]) paramAnnotationsArray[i];
                         paramAnnotationAttrs = (Object[]) paramAnnotationAttrsArray[i];
                     }
 
                     if (paramAnnotations != null) {
                         paramModTree = createModifiersTree(copynew Modifier[]{}, paramAnnotationsparamAnnotationAttrs);
                     }
                 }
 
                 paramTrees.add(maker.Variable(paramModTreeparameters[i], createTypeTree(copyparamTypes[i]), null));
             }
         }
 
         List<ExpressionTreethrowsExpressions = createThrowTrees(copythrowList);
 
         MethodTree methodTree = maker.Method(modifiersTreenamereturnTypeTree, Collections.<TypeParameterTree>emptyList(), paramTreesthrowsExpressionsbodyTextnull);
 
         if (comment != null) {
             maker.addComment(methodTreecreateJavaDocComment(comment), true);
         }
 
         return maker.addClassMember(treemethodTree);
     }
 
     public static AssignmentTree createAssignmentTree(WorkingCopy copyString variableObject value) {
         TreeMaker maker = copy.getTreeMaker();
 
         return maker.Assignment(maker.Identifier(variable), maker.Literal(value));
     }
 
     private static Tree createTypeTree(WorkingCopy copyObject type) {
         if (type instanceof String) {
             String typeString = (Stringtype;
             if (typeString.indexOf("<") != -1) {
                 return createParameterizedTypeTree(copytypeString);
             } else {
                 TypeElement element = copy.getElements().getTypeElement(typeString);
                 if (element != null) {
                     return copy.getTreeMaker().QualIdent(element);
                 } else {
                     return copy.getTreeMaker().Identifier(typeString);
                 }
             }
         } else {
             return (Treetype;
         }
     }
 
     public static Tree createIdentifierTree(WorkingCopy copyString value) {
         return copy.getTreeMaker().Identifier(value);
     }
 
     private static Tree createParameterizedTypeTree(WorkingCopy copyString parameterizedType) {
         int left = parameterizedType.indexOf("<");
         int right = parameterizedType.lastIndexOf(">");
         String genericType = parameterizedType.substring(0, left);
         String types = parameterizedType.substring(left + 1, right);
         StringTokenizer tokenizer = new StringTokenizer(types",");
         String[] typeArgs = new String[tokenizer.countTokens()];
         int count = 0;
         while (tokenizer.hasMoreTokens()) {
             typeArgs[count++] = tokenizer.nextToken();
         }
         return createParameterizedTypeTree(copygenericTypetypeArgs);
     }
 
     public static Tree createParameterizedTypeTree(WorkingCopy copyString typeString[] typeArgs) {
         TreeMaker maker = copy.getTreeMaker();
         Tree typeTree = createTypeTree(copytype);
         List<ExpressionTreetypeArgTrees = new ArrayList<ExpressionTree>();
 
         for (String arg : typeArgs) {
             typeArgTrees.add((ExpressionTreecreateTypeTree(copyarg));
         }
 
         return maker.ParameterizedType(typeTreetypeArgTrees);
     }
 
     private static ModifiersTree createModifiersTree(WorkingCopy copyModifier[] modifiersString[] annotationsObject[] annotationAttrs) {
         TreeMaker maker = copy.getTreeMaker();
         Set<ModifiermodifierSet = new HashSet<Modifier>();
 
         for (Modifier modifier : modifiers) {
             modifierSet.add(modifier);
         }
 
         List<AnnotationTreeannotationTrees = createAnnotationTrees(copyannotationsannotationAttrs);
 
         return maker.Modifiers(modifierSetannotationTrees);
     }
 
     private static List<AnnotationTreecreateAnnotationTrees(WorkingCopy copyString[] annotationsObject[] annotationAttrs) {
         TreeMaker maker = copy.getTreeMaker();
         List<AnnotationTreeannotationTrees = null;
 
         if (annotations != null) {
             annotationTrees = new ArrayList<AnnotationTree>();
 
             for (int i = 0; i < annotations.lengthi++) {
                 String annotation = annotations[i];
                 List<ExpressionTreeexpressionTrees = Collections.<ExpressionTree>emptyList();
 
                 if (annotationAttrs != null) {
                     Object attr = annotationAttrs[i];
 
                     if (attr != null) {
                         expressionTrees = new ArrayList<ExpressionTree>();
 
                         if (attr instanceof ExpressionTree) {
                             expressionTrees.add((ExpressionTreeattr);
                         } else {
                             expressionTrees.add(maker.Literal(attr));
                         }
                     }
                 }
                 annotationTrees.add(maker.Annotation(createTypeTree(copyannotation), expressionTrees));
             }
         } else {
             annotationTrees = Collections.<AnnotationTree>emptyList();
         }
 
         return annotationTrees;
     }
 
     private static List<ExpressionTreecreateThrowTrees(WorkingCopy copyObject[] throwList) {
         TreeMaker maker = copy.getTreeMaker();
         List<ExpressionTreethrowTrees = Collections.<ExpressionTree>emptyList();
         if (throwList != null) {
             throwTrees = new ArrayList<ExpressionTree>();
             for (int i = 0; i < throwList.lengthi++) {
                 Object throwType = throwList[i];
                 //throwTrees.add(maker.Throw(maker.Literal(throwClass)).getExpression());
                 TypeElement element = copy.getElements().getTypeElement((StringthrowType);
                 throwTrees.add(maker.QualIdent(element));
             }
         }
         return throwTrees;
     }
 
     private static Comment createJavaDocComment(String text) {
 
         return Comment.create(., -2, -2, -2, text);
     }

    
Finds the first public top-level type in the compilation unit given by the given CompilationController. This method assumes the restriction that there is at most a public top-level type declaration in a compilation unit, as described in the section 7.6 of the JLS.
 
     public static ClassTree findPublicTopLevelClass(CompilationController controllerthrows IOException {
         controller.toPhase(.);
 
         final String mainElementName = controller.getFileObject().getName();
         for (Tree tree : controller.getCompilationUnit().getTypeDecls()) {
             if (!..contains(tree.getKind())) {
                 continue;
             }
             ClassTree classTree = (ClassTreetree;
             if (!classTree.getSimpleName().contentEquals(mainElementName)) {
                 continue;
             }
             if (!classTree.getModifiers().getFlags().contains(.)) {
                 continue;
             }
             return classTree;
         }
         return null;
     }
 
     public static boolean isInjectionTarget(CompilationController controllerthrows IOException {
         Parameters.notNull("controller"controller); // NOI18N
         ClassTree classTree = findPublicTopLevelClass(controller);
         if (classTree == null) {
             throw new IllegalArgumentException();
         }
 
         return isInjectionTarget(controllergetTypeElement(controllerclassTree));
     }
 
     public static boolean isInjectionTarget(CompilationController controllerTypeElement typeElement) {
         FileObject fo = controller.getFileObject();
         Project project = FileOwnerQuery.getOwner(fo);
         if (. != typeElement.getKind()) {
             List<? extends AnnotationMirrorannotations = typeElement.getAnnotationMirrors();
             boolean found = false;
 
             for (AnnotationMirror m : annotations) {
                 Name qualifiedName = ((TypeElementm.getAnnotationType().asElement()).getQualifiedName();
                 if (qualifiedName.contentEquals("javax.jws.WebService")) {
                     //NOI18N
                     found = true;
                     break;
                 }
                 if (qualifiedName.contentEquals("javax.jws.WebServiceProvider")) {
                     //NOI18N
                     found = true;
                     break;
                 }
             }
             if (found) {
                 return true;
             }
         }
         return false;
     }
 
     public static TypeElement getTypeElement(CompilationController controllerClassTree classTree) {
         TreePath classTreePath = controller.getTrees().getPath(controller.getCompilationUnit(), classTree);
         return (TypeElementcontroller.getTrees().getElement(classTreePath);
     }
 
     public static TypeElement getTypeElement(CompilationController controllerTreePath treePath) {
         return (TypeElementcontroller.getTrees().getElement(treePath);
     }
 
     public static ClassTree getClassTree(CompilationController controllerTypeElement typeElement) {
         return controller.getTrees().getTree(typeElement);
     }
 
     public static void saveSource(FileObject[] filesthrows IOException {
         for (FileObject f : files) {
             try {
                 DataObject dobj = DataObject.find(f);
                 SaveCookie sc = dobj.getCookie(SaveCookie.class);
                 if (sc != null) {
                     sc.save();
                 }
             } catch (DataObjectNotFoundException dex) {
                 // something really wrong but continue trying to save others
             }
         }
     }
 
     public static boolean isOfAnnotationType(AnnotationMirror amString annotationType) {
         return annotationType.equals(am.toString().substring(1));
     }
 
     public static AnnotationMirror findAnnotation(List<? extends AnnotationMirroranmirsString annotationString) {
         for (AnnotationMirror am : anmirs) {
             if (isOfAnnotationType(amannotationString)) {
                 return am;
             }
         }
         return null;
     }
 
     public static boolean annotationHasAttributeValue(AnnotationMirror amString attrString value) {
         return value.equals(am.getElementValues().get(attr));
     }
 
     public static boolean annotationHasAttributeValue(AnnotationMirror amString value) {
         if (am != null) {
             for (AnnotationValue av : am.getElementValues().values()) {
                 if (value.equals(av.getValue())) {
                     return true;
                 }
             }
         }
         return false;
     }
 
     public static TypeElement getXmlRepresentationClass(TypeElement typeElementString defaultSuffix) {
 
         List<ExecutableElementmethods = ElementFilter.methodsIn(typeElement.getEnclosedElements());
         for (ExecutableElement method : methods) {
             List<? extends AnnotationMirroranmirs = method.getAnnotationMirrors();
 
             AnnotationMirror mirrorHttpMethod = findAnnotation(anmirs.);
             if (mirrorHttpMethod != null) {
                 TypeMirror tm = method.getReturnType();
                 if (tm != null && tm.getKind() == .) {
                     TypeElement returnType = (TypeElement) ((DeclaredTypetm).asElement();
                     if (returnType.getSimpleName().toString().endsWith(defaultSuffix)) {
                         return returnType;
                     }
                 }
             }
         }
         return null;
     }
 
     public static TypeElement getTypeElement(JavaSource sourcethrows IOException {
         final TypeElement[] results = new TypeElement[1];
 
         source.runUserActionTask(new AbstractTask<CompilationController>() {
 
             public void run(CompilationController controllerthrows IOException {
                 controller.toPhase(..);
                 results[0] = getTopLevelClassElement(controller);
             }
         }, true);
 
         return results[0];
     }
 
     public static JavaSource forTypeElement(TypeElement typeElementProject projectthrows IOException {
         for (JavaSource js : getJavaSources(project)) {
             String className = getClassType(js);
             if (typeElement.getQualifiedName().contentEquals(className)) {
                 return js;
             }
         }
         return null;
     }
 
     public static List<? extends AnnotationMirrorgetClassAnnotations(JavaSource source) {
         final List<? extends AnnotationMirror>[] classAnons = new List[1];
 
         try {
             source.runUserActionTask(new AbstractTask<CompilationController>() {
 
                 public void run(CompilationController controllerthrows IOException {
                     controller.toPhase(..);
 
                     TypeElement classElement = getTopLevelClassElement(controller);
                     if (classElement == null) {
                         return;
                     }
 
                     classAnons[0] = controller.getElements().getAllAnnotationMirrors(classElement);
                 }
             }, true);
         } catch (IOException ex) {
         }
 
         return classAnons[0];
     }
 
     public static List<? extends TreegetAllTree(JavaSource source) {
         final List<? extends Tree>[] allTree = new List[1];
 
         try {
             source.runUserActionTask(new AbstractTask<CompilationController>() {
 
                 public void run(CompilationController controllerthrows IOException {
                     String className = controller.getFileObject().getName();
                     CompilationUnitTree cu = controller.getCompilationUnit();
                     if (cu != null) {
                         allTree[0] = cu.getTypeDecls();
                     }
                 }
             }, true);
         } catch (IOException ex) {
             ex.printStackTrace();
         }
         return allTree[0];
     }
 
     public static List<VariableTreegetAllFields(JavaSource source) {
         final List<VariableTreeallFields = new ArrayList<VariableTree>();
 
         try {
             source.runUserActionTask(new AbstractTask<CompilationController>() {
 
                 public void run(CompilationController controllerthrows IOException {
                     controller.toPhase(..);
                     TypeElement classElement = getTopLevelClassElement(controller);
                     List<VariableElementfields = ElementFilter.fieldsIn(classElement.getEnclosedElements());
 
                     for (VariableElement field : fields) {
                         allFields.add((VariableTreecontroller.getTrees().getTree(field));
                     }
                 }
             }, true);
         } catch (IOException ex) {
         }
         return allFields;
     }
 
     public static List<MethodTreegetAllConstuctors(JavaSource source) {
         final List<MethodTreeallConstuctors = new ArrayList<MethodTree>();
 
         try {
             source.runUserActionTask(new AbstractTask<CompilationController>() {
 
                 public void run(CompilationController controllerthrows IOException {
                     controller.toPhase(..);
                     TypeElement classElement = getTopLevelClassElement(controller);
                     List<ExecutableElementconstuctors = ElementFilter.constructorsIn(classElement.getEnclosedElements());
 
                     for (ExecutableElement constuctor : constuctors) {
                         allConstuctors.add(controller.getTrees().getTree(constuctor));
                     }
                 }
             }, true);
         } catch (IOException ex) {
         }
         return allConstuctors;
     }
 
     public static List<MethodTreegetAllMethods(JavaSource source) {
         final List<MethodTreeallMethods = new ArrayList<MethodTree>();
 
         try {
             source.runUserActionTask(new