jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/tools/internal/ws/processor/modeler/annotation/WebServiceWrapperGenerator.java@9c07ef4934dd

     1 /*

     2  * Copyright (c) 1997, 2013, 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  */

    26 package com.sun.tools.internal.ws.processor.modeler.annotation;

    28 import com.sun.codemodel.internal.CodeWriter;

    29 import com.sun.codemodel.internal.JAnnotationArrayMember;

    30 import com.sun.codemodel.internal.JAnnotationUse;

    31 import com.sun.codemodel.internal.JBlock;

    32 import com.sun.codemodel.internal.JCodeModel;

    33 import com.sun.codemodel.internal.JCommentPart;

    34 import com.sun.codemodel.internal.JDefinedClass;

    35 import com.sun.codemodel.internal.JDocComment;

    36 import com.sun.codemodel.internal.JExpr;

    37 import com.sun.codemodel.internal.JFieldVar;

    38 import com.sun.codemodel.internal.JMethod;

    39 import com.sun.codemodel.internal.JMod;

    40 import com.sun.codemodel.internal.JType;

    41 import com.sun.codemodel.internal.JVar;

    42 import com.sun.codemodel.internal.writer.ProgressCodeWriter;

    43 import com.sun.tools.internal.jxc.ap.InlineAnnotationReaderImpl;

    44 import com.sun.tools.internal.jxc.model.nav.ApNavigator;

    45 import com.sun.tools.internal.ws.ToolVersion;

    46 import com.sun.tools.internal.ws.processor.generator.GeneratorBase;

    47 import com.sun.tools.internal.ws.processor.generator.GeneratorConstants;

    48 import com.sun.tools.internal.ws.processor.generator.Names;

    49 import com.sun.tools.internal.ws.processor.modeler.ModelerException;

    50 import com.sun.tools.internal.ws.processor.util.DirectoryUtil;

    51 import com.sun.tools.internal.ws.resources.WebserviceapMessages;

    52 import com.sun.tools.internal.ws.util.ClassNameInfo;

    53 import com.sun.tools.internal.ws.wscompile.FilerCodeWriter;

    54 import com.sun.tools.internal.ws.wscompile.WsgenOptions;

    55 import com.sun.tools.internal.ws.wsdl.document.soap.SOAPStyle;

    56 import com.sun.xml.internal.bind.v2.model.annotation.AnnotationReader;

    57 import com.sun.xml.internal.bind.v2.model.nav.Navigator;

    58 import com.sun.xml.internal.ws.model.AbstractWrapperBeanGenerator;

    59 import com.sun.xml.internal.ws.spi.db.BindingHelper;

    60 import com.sun.xml.internal.ws.util.StringUtils;

    62 import javax.jws.Oneway;

    63 import javax.jws.WebMethod;

    64 import javax.jws.WebService;

    65 import javax.lang.model.element.ExecutableElement;

    66 import javax.lang.model.element.Name;

    67 import javax.lang.model.element.TypeElement;

    68 import javax.lang.model.type.DeclaredType;

    69 import javax.lang.model.type.MirroredTypeException;

    70 import javax.lang.model.type.TypeKind;

    71 import javax.lang.model.type.TypeMirror;

    72 import javax.xml.bind.annotation.XmlAccessType;

    73 import javax.xml.bind.annotation.XmlAccessorType;

    74 import javax.xml.bind.annotation.XmlAttachmentRef;

    75 import javax.xml.bind.annotation.XmlElement;

    76 import javax.xml.bind.annotation.XmlList;

    77 import javax.xml.bind.annotation.XmlMimeType;

    78 import javax.xml.bind.annotation.XmlRootElement;

    79 import javax.xml.bind.annotation.XmlType;

    80 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

    81 import javax.xml.namespace.QName;

    82 import javax.xml.ws.RequestWrapper;

    83 import javax.xml.ws.ResponseWrapper;

    84 import javax.xml.ws.WebFault;

    85 import javax.xml.ws.WebServiceException;

    86 import java.io.File;

    87 import java.io.IOException;

    88 import java.lang.annotation.Annotation;

    89 import java.util.Collection;

    90 import java.util.HashSet;

    91 import java.util.List;

    92 import java.util.Set;

    94 import static com.sun.codemodel.internal.ClassType.CLASS;

    95 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.BEAN;

    96 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.FAULT_INFO;

    97 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.JAXWS_PACKAGE_PD;

    98 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.PD_JAXWS_PACKAGE_PD;

    99 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.RESPONSE;

   101 /**

   102  * This class generates the request/response and Exception Beans

   103  * used by the JAX-WS runtime.

   104  *

   105  * @author  WS Development Team

   106  */

   107 public class WebServiceWrapperGenerator extends WebServiceVisitor {

   108     private Set<String> wrapperNames;

   109     private Set<String> processedExceptions;

   110     private JCodeModel cm;

   111     private final MakeSafeTypeVisitor makeSafeVisitor;

   113     private static final FieldFactory FIELD_FACTORY = new FieldFactory();

   115     private final AbstractWrapperBeanGenerator ap_generator =

   116             new ApWrapperBeanGenerator(InlineAnnotationReaderImpl.theInstance,

   117                     new ApNavigator(builder.getProcessingEnvironment()), FIELD_FACTORY);

   119     private final class ApWrapperBeanGenerator extends AbstractWrapperBeanGenerator<TypeMirror, TypeElement, ExecutableElement, MemberInfo> {

   121         protected ApWrapperBeanGenerator(

   122                 AnnotationReader<TypeMirror, TypeElement, ?, ExecutableElement> annReader,

   123                 Navigator<TypeMirror, TypeElement, ?, ExecutableElement> nav, BeanMemberFactory<TypeMirror, MemberInfo> beanMemberFactory) {

   124             super(annReader, nav, beanMemberFactory);

   125         }

   127         @Override

   128         protected TypeMirror getSafeType(TypeMirror type) {

   129             return WebServiceWrapperGenerator.this.getSafeType(type);

   130         }

   132         @Override

   133         protected TypeMirror getHolderValueType(TypeMirror paramType) {

   134             return builder.getHolderValueType(paramType);

   135         }

   137         @Override

   138         protected boolean isVoidType(TypeMirror type) {

   139             return type != null && type.getKind().equals(TypeKind.VOID);

   140         }

   142     }

   144     private static final class FieldFactory implements AbstractWrapperBeanGenerator.BeanMemberFactory<TypeMirror, MemberInfo> {

   146         @Override

   147         public MemberInfo createWrapperBeanMember(TypeMirror paramType,

   148                                                   String paramName, List<Annotation> jaxb) {

   149             return new MemberInfo(paramType, paramName, jaxb);

   150         }

   151     }

   153     public WebServiceWrapperGenerator(ModelBuilder builder, AnnotationProcessorContext context) {

   154         super(builder, context);

   155         makeSafeVisitor = new MakeSafeTypeVisitor(builder.getProcessingEnvironment());

   156     }

   158     @Override

   159     protected void processWebService(WebService webService, TypeElement d) {

   160         cm = new JCodeModel();

   161         wrapperNames = new HashSet<String>();

   162         processedExceptions = new HashSet<String>();

   163     }

   165     @Override

   166     protected void postProcessWebService(WebService webService, TypeElement d) {

   167         super.postProcessWebService(webService, d);

   168         doPostProcessWebService(webService, d);

   169     }

   171     @SuppressWarnings("CallToThreadDumpStack")

   172     protected void doPostProcessWebService(WebService webService, TypeElement d) {

   173         if (cm != null) {

   174             File sourceDir = builder.getSourceDir();

   175             assert(sourceDir != null);

   176             WsgenOptions options = builder.getOptions();

   177             try {

   178                 CodeWriter cw = new FilerCodeWriter(sourceDir, options);

   179                 if(options.verbose)

   180                     cw = new ProgressCodeWriter(cw, System.out);

   181                 cm.build(cw);

   182             } catch (IOException e) {

   183                 e.printStackTrace();

   184             }

   185         }

   186     }

   188     @Override

   189     protected void processMethod(ExecutableElement method, WebMethod webMethod) {

   190         builder.log("WrapperGen - method: "+method);

   191         builder.log("method.getDeclaringType(): " + method.asType());

   192         if (wrapped && soapStyle.equals(SOAPStyle.DOCUMENT)) {

   193             generateWrappers(method, webMethod);

   194         }

   195         generateExceptionBeans(method);

   196     }

   198     private boolean generateExceptionBeans(ExecutableElement method) {

   199         String beanPackage = packageName + PD_JAXWS_PACKAGE_PD.getValue();

   200         if (packageName.length() == 0)

   201             beanPackage = JAXWS_PACKAGE_PD.getValue();

   202         boolean beanGenerated = false;

   203         for (TypeMirror thrownType : method.getThrownTypes()) {

   204             TypeElement typeDecl = (TypeElement) ((DeclaredType) thrownType).asElement();

   205             if (typeDecl == null) {

   206                 builder.processError(WebserviceapMessages.WEBSERVICEAP_COULD_NOT_FIND_TYPEDECL(

   207                         thrownType.toString(), context.getRound()));

   208                 return false;

   209             }

   210             boolean tmp = generateExceptionBean(typeDecl, beanPackage);

   211             beanGenerated = beanGenerated || tmp;

   212         }

   213         return beanGenerated;

   214     }

   216     private boolean duplicateName(String name) {

   217         for (String str : wrapperNames) {

   218             if (str.equalsIgnoreCase(name))

   219         return true;

   220         }

   221         wrapperNames.add(name);

   222     return false;

   223     }

   225     private boolean generateWrappers(ExecutableElement method, WebMethod webMethod) {

   226         boolean isOneway = method.getAnnotation(Oneway.class) != null;

   227         String beanPackage = packageName + PD_JAXWS_PACKAGE_PD.getValue();

   228         if (packageName.length() == 0)

   229             beanPackage = JAXWS_PACKAGE_PD.getValue();

   230         Name methodName = method.getSimpleName();

   231         String operationName = builder.getOperationName(methodName);

   232         operationName = webMethod != null && webMethod.operationName().length() > 0 ?

   233                 webMethod.operationName() : operationName;

   234         String reqName = operationName;

   235         String resName = operationName + WebServiceConstants.RESPONSE.getValue();

   236         String reqNamespace = typeNamespace;

   237         String resNamespace = typeNamespace;

   239         String requestClassName = beanPackage + StringUtils.capitalize(method.getSimpleName().toString());

   240         RequestWrapper reqWrapper = method.getAnnotation(RequestWrapper.class);

   241         if (reqWrapper != null) {

   242             if (reqWrapper.className().length() > 0)

   243                 requestClassName = reqWrapper.className();

   244             if (reqWrapper.localName().length() > 0)

   245                 reqName = reqWrapper.localName();

   246             if (reqWrapper.targetNamespace().length() > 0)

   247                 reqNamespace = reqWrapper.targetNamespace();

   248         }

   249         builder.log("requestWrapper: "+requestClassName);

   250 ///// fix for wsgen CR 6442344

   251         File file = new File(DirectoryUtil.getOutputDirectoryFor(requestClassName, builder.getSourceDir()),

   252                 Names.stripQualifier(requestClassName) + GeneratorConstants.JAVA_SRC_SUFFIX.getValue());

   253         builder.getOptions().addGeneratedFile(file);

   254 //////////

   255         boolean canOverwriteRequest = builder.canOverWriteClass(requestClassName);

   256         if (!canOverwriteRequest) {

   257             builder.log("Class " + requestClassName + " exists. Not overwriting.");

   258         }

   259         if (duplicateName(requestClassName) && canOverwriteRequest) {

   260             builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_REQUEST_WRAPPER_BEAN_NAME_NOT_UNIQUE(

   261                     typeElement.getQualifiedName(), method.toString()));

   262         }

   264         String responseClassName = null;

   265         boolean canOverwriteResponse = canOverwriteRequest;

   266         if (!isOneway) {

   267             responseClassName = beanPackage+StringUtils.capitalize(method.getSimpleName().toString())+RESPONSE.getValue();

   268             ResponseWrapper resWrapper = method.getAnnotation(ResponseWrapper.class);

   269             if(resWrapper != null) {

   270                 if (resWrapper.className().length() > 0)

   271                     responseClassName = resWrapper.className();

   272                 if (resWrapper.localName().length() > 0)

   273                     resName = resWrapper.localName();

   274                 if (resWrapper.targetNamespace().length() > 0)

   275                     resNamespace = resWrapper.targetNamespace();

   276             }

   277             canOverwriteResponse = builder.canOverWriteClass(responseClassName);

   278             if (!canOverwriteResponse) {

   279                 builder.log("Class " + responseClassName + " exists. Not overwriting.");

   280             }

   281             if (duplicateName(responseClassName) && canOverwriteResponse) {

   282                 builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_RESPONSE_WRAPPER_BEAN_NAME_NOT_UNIQUE(

   283                         typeElement.getQualifiedName(), method.toString()));

   284             }

   285             file = new File(DirectoryUtil.getOutputDirectoryFor(responseClassName, builder.getSourceDir()),

   286                     Names.stripQualifier(responseClassName) + GeneratorConstants.JAVA_SRC_SUFFIX.getValue());

   287             builder.getOptions().addGeneratedFile(file);

   288         }

   289         //ArrayList<MemberInfo> reqMembers = new ArrayList<MemberInfo>();

   290         //ArrayList<MemberInfo> resMembers = new ArrayList<MemberInfo>();

   291         WrapperInfo reqWrapperInfo = new WrapperInfo(requestClassName);

   292         //reqWrapperInfo.setMembers(reqMembers);

   293         WrapperInfo resWrapperInfo = null;

   294         if (!isOneway) {

   295             resWrapperInfo = new WrapperInfo(responseClassName);

   296             //resWrapperInfo.setMembers(resMembers);

   297         }

   298         seiContext.setReqWrapperOperation(method, reqWrapperInfo);

   299         if (!isOneway)

   300             seiContext.setResWrapperOperation(method, resWrapperInfo);

   301         try {

   302             if (!canOverwriteRequest && !canOverwriteResponse) {

   303                 return false;

   304             }

   306             JDefinedClass reqCls = null;

   307             if (canOverwriteRequest) {

   308                 reqCls = getCMClass(requestClassName, CLASS);

   309             }

   311             JDefinedClass resCls = null;

   312             if (!isOneway && canOverwriteResponse) {

   313                 resCls = getCMClass(responseClassName, CLASS);

   314             }

   316             // XMLElement Declarations

   317             writeXmlElementDeclaration(reqCls, reqName,reqNamespace);

   318             writeXmlElementDeclaration(resCls, resName, resNamespace);

   320             List<MemberInfo> reqMembers = ap_generator.collectRequestBeanMembers(method);

   321             List<MemberInfo> resMembers = ap_generator.collectResponseBeanMembers(method);

   323             // XmlType

   324             writeXmlTypeDeclaration(reqCls, reqName, reqNamespace, reqMembers);

   325             writeXmlTypeDeclaration(resCls, resName, resNamespace, resMembers);

   327             // class members

   328             writeMembers(reqCls, reqMembers);

   329             writeMembers(resCls, resMembers);

   331         } catch (Exception e) {

   332             throw new ModelerException("modeler.nestedGeneratorError",e);

   333         }

   334         return true;

   335     }

   337 //    private List<Annotation> collectJAXBAnnotations(Declaration decl) {

   338 //        List<Annotation> jaxbAnnotation = new ArrayList<Annotation>();

   339 //        for(Class jaxbClass : jaxbAnns) {

   340 //            Annotation ann = decl.getAnnotation(jaxbClass);

   341 //            if (ann != null) {

   342 //                jaxbAnnotation.add(ann);

   343 //            }

   344 //        }

   345 //        return jaxbAnnotation;

   346 //    }

   348     private TypeMirror getSafeType(TypeMirror type) {

   349         return makeSafeVisitor.visit(type, builder.getProcessingEnvironment().getTypeUtils());

   350     }

   352     private JType getType(TypeMirror typeMirror) {

   353         String type = typeMirror.toString();

   354         try {

   355 //            System.out.println("typeName: "+typeName);

   356             return cm.parseType(type);

   357 //            System.out.println("type: "+type);

   358         } catch (ClassNotFoundException e) {

   359             return cm.ref(type);

   360         }

   361     }

   363     private void writeMembers(JDefinedClass cls, Collection<MemberInfo> members) {

   364         if (cls == null)

   365             return;

   366         for (MemberInfo memInfo : members) {

   367             JType type = getType(memInfo.getParamType());

   368             JFieldVar field = cls.field(JMod.PRIVATE, type, memInfo.getParamName());

   369             annotateParameterWithJaxbAnnotations(memInfo, field);

   370         }

   371         for (MemberInfo memInfo : members) {

   372             writeMember(cls, memInfo.getParamType(),

   373                     memInfo.getParamName());

   374         }

   375     }

   377     private void annotateParameterWithJaxbAnnotations(MemberInfo memInfo, JFieldVar field) {

   378         List<Annotation> jaxbAnnotations = memInfo.getJaxbAnnotations();

   379         for(Annotation ann : jaxbAnnotations) {

   380             if (ann instanceof XmlMimeType) {

   381                 JAnnotationUse jaxbAnn = field.annotate(XmlMimeType.class);

   382                 jaxbAnn.param("value", ((XmlMimeType)ann).value());

   383             } else if (ann instanceof XmlJavaTypeAdapter) {

   384                 JAnnotationUse jaxbAnn = field.annotate(XmlJavaTypeAdapter.class);

   385                 XmlJavaTypeAdapter ja = (XmlJavaTypeAdapter) ann;

   386                 try {

   387                     ja.value();

   388                     throw new AssertionError();

   389                 } catch (MirroredTypeException e) {

   390                     jaxbAnn.param("value",getType(e.getTypeMirror()));

   391                 }

   392                 // XmlJavaTypeAdapter.type() is for package only. No need to copy.

   393             } else if (ann instanceof XmlAttachmentRef) {

   394                 field.annotate(XmlAttachmentRef.class);

   395             } else if (ann instanceof XmlList){

   396                 field.annotate(XmlList.class);

   397             } else if (ann instanceof XmlElement) {

   398                 XmlElement elemAnn = (XmlElement)ann;

   399                 JAnnotationUse jAnn = field.annotate(XmlElement.class);

   400                 jAnn.param("name", elemAnn.name());

   401                 jAnn.param("namespace", elemAnn.namespace());

   402                 if (elemAnn.nillable()) {

   403                     jAnn.param("nillable", true);

   404                 }

   405                 if (elemAnn.required()) {

   406                      jAnn.param("required", true);

   407                 }

   408             } else {

   409                 throw new WebServiceException("SEI Parameter cannot have this JAXB annotation: " + ann);

   410             }

   411         }

   412     }

   414     protected JDefinedClass getCMClass(String className, com.sun.codemodel.internal.ClassType type) {

   415         JDefinedClass cls;

   416         try {

   417             cls = cm._class(className, type);

   418         } catch (com.sun.codemodel.internal.JClassAlreadyExistsException e){

   419             cls = cm._getClass(className);

   420         }

   421         return cls;

   422     }

   424     private boolean generateExceptionBean(TypeElement thrownDecl, String beanPackage) {

   425         if (!builder.isServiceException(thrownDecl.asType()))

   426             return false;

   428         String exceptionName = ClassNameInfo.getName(thrownDecl.getQualifiedName().toString());

   429         if (processedExceptions.contains(exceptionName))

   430             return false;

   431         processedExceptions.add(exceptionName);

   432         WebFault webFault = thrownDecl.getAnnotation(WebFault.class);

   433         String className = beanPackage+ exceptionName + BEAN.getValue();

   435         Collection<MemberInfo> members = ap_generator.collectExceptionBeanMembers(thrownDecl);

   436         boolean isWSDLException = isWSDLException(members, thrownDecl);

   437         String namespace = typeNamespace;

   438         String name = exceptionName;

   439         FaultInfo faultInfo;

   440         if (isWSDLException) {

   441             TypeMirror beanType =  getFaultInfoMember(members).getParamType();

   442             faultInfo = new FaultInfo(TypeMonikerFactory.getTypeMoniker(beanType), true);

   443             namespace = webFault.targetNamespace().length()>0 ?

   444                                webFault.targetNamespace() : namespace;

   445             name = webFault.name().length()>0 ?

   446                           webFault.name() : name;

   447             faultInfo.setElementName(new QName(namespace, name));

   448             seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);

   449             return false;

   450         }

   451         if (webFault != null) {

   452             namespace = webFault.targetNamespace().length()>0 ?

   453                         webFault.targetNamespace() : namespace;

   454             name = webFault.name().length()>0 ?

   455                    webFault.name() : name;

   456             className = webFault.faultBean().length()>0 ?

   457                         webFault.faultBean() : className;

   459         }

   460         JDefinedClass cls = getCMClass(className, CLASS);

   461         faultInfo = new FaultInfo(className, false);

   463         if (duplicateName(className)) {

   464             builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_EXCEPTION_BEAN_NAME_NOT_UNIQUE(

   465                     typeElement.getQualifiedName(), thrownDecl.getQualifiedName()));

   466         }

   468         boolean canOverWriteBean = builder.canOverWriteClass(className);

   469         if (!canOverWriteBean) {

   470             builder.log("Class " + className + " exists. Not overwriting.");

   471             seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);

   472             return false;

   473         }

   474         if (seiContext.getExceptionBeanName(thrownDecl.getQualifiedName()) != null)

   475             return false;

   477         //write class comment - JAXWS warning

   478         JDocComment comment = cls.javadoc();

   479         for (String doc : GeneratorBase.getJAXWSClassComment(ToolVersion.VERSION.MAJOR_VERSION)) {

   480             comment.add(doc);

   481         }

   483         // XmlElement Declarations

   484         writeXmlElementDeclaration(cls, name, namespace);

   486         // XmlType Declaration

   487         //members = sortMembers(members);

   488         XmlType xmlType = thrownDecl.getAnnotation(XmlType.class);

   489         String xmlTypeName = (xmlType != null && !xmlType.name().equals("##default")) ? xmlType.name() : exceptionName;

   490         String xmlTypeNamespace = (xmlType != null && !xmlType.namespace().equals("##default")) ? xmlType.namespace() : typeNamespace;

   491         writeXmlTypeDeclaration(cls, xmlTypeName, xmlTypeNamespace, members);

   493         writeMembers(cls, members);

   495         seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);

   496         return true;

   497     }

   499     protected boolean isWSDLException(Collection<MemberInfo> members, TypeElement thrownDecl) {

   500         WebFault webFault = thrownDecl.getAnnotation(WebFault.class);

   501         return webFault != null && members.size() == 2 && getFaultInfoMember(members) != null;

   502     }

   504     /*

   505      * Returns the corresponding MemberInfo for getFaultInfo()

   506      * method of an exception. Returns null, if that method is not there.

   507      */

   508     private MemberInfo getFaultInfoMember(Collection<MemberInfo> members) {

   509         for(MemberInfo member : members) {

   510             if (member.getParamName().equals(FAULT_INFO.getValue())) {

   511                 return member;

   512             }

   513         }

   514         return null;

   515     }

   517     private void writeXmlElementDeclaration(JDefinedClass cls, String elementName, String namespaceUri) {

   519        if (cls == null)

   520             return;

   521         JAnnotationUse xmlRootElementAnn = cls.annotate(XmlRootElement.class);

   522         xmlRootElementAnn.param("name", elementName);

   523         if (namespaceUri.length() > 0) {

   524             xmlRootElementAnn.param("namespace", namespaceUri);

   525         }

   526         JAnnotationUse xmlAccessorTypeAnn = cls.annotate(cm.ref(XmlAccessorType.class));

   527         xmlAccessorTypeAnn.param("value", XmlAccessType.FIELD);

   528     }

   530     private void writeXmlTypeDeclaration(JDefinedClass cls, String typeName, String namespaceUri,

   531                                          Collection<MemberInfo> members) {

   532         if (cls == null)

   533             return;

   534         JAnnotationUse xmlTypeAnn = cls.annotate(cm.ref(XmlType.class));

   535         xmlTypeAnn.param("name", typeName);

   536         xmlTypeAnn.param("namespace", namespaceUri);

   537         if (members.size() > 1) {

   538             JAnnotationArrayMember paramArray = xmlTypeAnn.paramArray("propOrder");

   539             for (MemberInfo memInfo : members) {

   540                 paramArray.param(memInfo.getParamName());

   541             }

   542         }

   543     }

   545     private void writeMember(JDefinedClass cls, TypeMirror paramType,

   546                              String paramName) {

   548         if (cls == null)

   549             return;

   551         String accessorName =BindingHelper.mangleNameToPropertyName(paramName);

   552         String getterPrefix = paramType.toString().equals("boolean")? "is" : "get";

   553         JType propType = getType(paramType);

   554         JMethod m = cls.method(JMod.PUBLIC, propType, getterPrefix+ accessorName);

   555         JDocComment methodDoc = m.javadoc();

   556         JCommentPart ret = methodDoc.addReturn();

   557         ret.add("returns "+propType.name());

   558         JBlock body = m.body();

   559         body._return( JExpr._this().ref(paramName) );

   561         m = cls.method(JMod.PUBLIC, cm.VOID, "set"+accessorName);

   562         JVar param = m.param(propType, paramName);

   563         methodDoc = m.javadoc();

   564         JCommentPart part = methodDoc.addParam(paramName);

   565         part.add("the value for the "+ paramName+" property");

   566         body = m.body();

   567         body.assign( JExpr._this().ref(paramName), param );

   568     }

   569 }

Mercurial > jdk8-mips64-public > jaxws / file revision

src/share/jaxws_classes/com/sun/tools/internal/ws/processor/modeler/annotation/WebServiceWrapperGenerator.java@9c07ef4934dd

src/share/jaxws_classes/com/sun/tools/internal/ws/processor/modeler/annotation/WebServiceWrapperGenerator.java