jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/tools/internal/ws/processor/modeler/annotation/WebServiceWrapperGenerator.java@f50545b5e2f1 (annotated)

src/share/jaxws_classes/com/sun/tools/internal/ws/processor/modeler/annotation/WebServiceWrapperGenerator.java@f50545b5e2f1 (annotated)

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

Tue, 06 Mar 2012 16:09:35 -0800

author: ohair
date: Tue, 06 Mar 2012 16:09:35 -0800
changeset 286: f50545b5e2f1
child 368: 0989ad8c0860
permissions: -rw-r--r--

7150322: Stop using drop source bundles in jaxws
Reviewed-by: darcy, ohrstrom

 /*
  * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.tools.internal.ws.processor.modeler.annotation;
 import com.sun.codemodel.internal.CodeWriter;
 import com.sun.codemodel.internal.JAnnotationArrayMember;
 import com.sun.codemodel.internal.JAnnotationUse;
 import com.sun.codemodel.internal.JBlock;
 import com.sun.codemodel.internal.JCodeModel;
 import com.sun.codemodel.internal.JCommentPart;
 import com.sun.codemodel.internal.JDefinedClass;
 import com.sun.codemodel.internal.JDocComment;
 import com.sun.codemodel.internal.JExpr;
 import com.sun.codemodel.internal.JFieldVar;
 import com.sun.codemodel.internal.JMethod;
 import com.sun.codemodel.internal.JMod;
 import com.sun.codemodel.internal.JType;
 import com.sun.codemodel.internal.JVar;
 import com.sun.codemodel.internal.writer.ProgressCodeWriter;
 import com.sun.tools.internal.jxc.ap.InlineAnnotationReaderImpl;
 import com.sun.tools.internal.jxc.model.nav.ApNavigator;
 import com.sun.tools.internal.ws.ToolVersion;
 import com.sun.tools.internal.ws.processor.generator.GeneratorBase;
 import com.sun.tools.internal.ws.processor.generator.GeneratorConstants;
 import com.sun.tools.internal.ws.processor.generator.Names;
 import com.sun.tools.internal.ws.processor.modeler.ModelerException;
 import com.sun.tools.internal.ws.processor.util.DirectoryUtil;
 import com.sun.tools.internal.ws.resources.WebserviceapMessages;
 import com.sun.tools.internal.ws.util.ClassNameInfo;
 import com.sun.tools.internal.ws.wscompile.FilerCodeWriter;
 import com.sun.tools.internal.ws.wscompile.WsgenOptions;
 import com.sun.tools.internal.ws.wsdl.document.soap.SOAPStyle;
 import com.sun.xml.internal.bind.v2.model.annotation.AnnotationReader;
 import com.sun.xml.internal.bind.v2.model.nav.Navigator;
 import com.sun.xml.internal.ws.model.AbstractWrapperBeanGenerator;
 import com.sun.xml.internal.ws.spi.db.BindingHelper;
 import com.sun.xml.internal.ws.util.StringUtils;
 import javax.jws.Oneway;
 import javax.jws.WebMethod;
 import javax.jws.WebService;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.Name;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.MirroredTypeException;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
 import javax.xml.bind.annotation.XmlAttachmentRef;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlList;
 import javax.xml.bind.annotation.XmlMimeType;
 import javax.xml.bind.annotation.XmlRootElement;
 import javax.xml.bind.annotation.XmlType;
 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 import javax.xml.namespace.QName;
 import javax.xml.ws.RequestWrapper;
 import javax.xml.ws.ResponseWrapper;
 import javax.xml.ws.WebFault;
 import javax.xml.ws.WebServiceException;
 import java.io.File;
 import java.io.IOException;
 import java.lang.annotation.Annotation;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import static com.sun.codemodel.internal.ClassType.CLASS;
 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.BEAN;
 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.FAULT_INFO;
 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.JAXWS_PACKAGE_PD;
 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.PD_JAXWS_PACKAGE_PD;
 import static com.sun.tools.internal.ws.processor.modeler.annotation.WebServiceConstants.RESPONSE;
 /**
  * This class generates the request/response and Exception Beans
  * used by the JAX-WS runtime.
  *
  * @author  WS Development Team
  */
 public class WebServiceWrapperGenerator extends WebServiceVisitor {
     private Set<String> wrapperNames;
     private Set<String> processedExceptions;
     private JCodeModel cm;
     private final MakeSafeTypeVisitor makeSafeVisitor;
     private static final FieldFactory FIELD_FACTORY = new FieldFactory();
     private final AbstractWrapperBeanGenerator ap_generator =
             new ApWrapperBeanGenerator(InlineAnnotationReaderImpl.theInstance,
                     new ApNavigator(builder.getProcessingEnvironment()), FIELD_FACTORY);
     private final class ApWrapperBeanGenerator extends AbstractWrapperBeanGenerator<TypeMirror, TypeElement, ExecutableElement, MemberInfo> {
         protected ApWrapperBeanGenerator(
                 AnnotationReader<TypeMirror, TypeElement, ?, ExecutableElement> annReader,
                 Navigator<TypeMirror, TypeElement, ?, ExecutableElement> nav, BeanMemberFactory<TypeMirror, MemberInfo> beanMemberFactory) {
             super(annReader, nav, beanMemberFactory);
         }
         protected TypeMirror getSafeType(TypeMirror type) {
             return WebServiceWrapperGenerator.this.getSafeType(type);
         }
         protected TypeMirror getHolderValueType(TypeMirror paramType) {
             return builder.getHolderValueType(paramType);
         }
         protected boolean isVoidType(TypeMirror type) {
             return type != null && type.getKind().equals(TypeKind.VOID);
         }
     }
     private static final class FieldFactory implements AbstractWrapperBeanGenerator.BeanMemberFactory<TypeMirror, MemberInfo> {
         public MemberInfo createWrapperBeanMember(TypeMirror paramType,
                                                   String paramName, List<Annotation> jaxb) {
             return new MemberInfo(paramType, paramName, jaxb);
         }
     }
     public WebServiceWrapperGenerator(ModelBuilder builder, AnnotationProcessorContext context) {
         super(builder, context);
         makeSafeVisitor = new MakeSafeTypeVisitor(builder.getProcessingEnvironment());
     }
     protected void processWebService(WebService webService, TypeElement d) {
         cm = new JCodeModel();
         wrapperNames = new HashSet<String>();
         processedExceptions = new HashSet<String>();
     }
     protected void postProcessWebService(WebService webService, TypeElement d) {
         super.postProcessWebService(webService, d);
         doPostProcessWebService(webService, d);
     }
     protected void doPostProcessWebService(WebService webService, TypeElement d) {
         if (cm != null) {
             File sourceDir = builder.getSourceDir();
             assert(sourceDir != null);
             WsgenOptions options = builder.getOptions();
             try {
                 CodeWriter cw = new FilerCodeWriter(sourceDir, options);
                 if(options.verbose)
                     cw = new ProgressCodeWriter(cw, System.out);
                 cm.build(cw);
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }
     protected void processMethod(ExecutableElement method, WebMethod webMethod) {
         builder.log("WrapperGen - method: "+method);
         builder.log("method.getDeclaringType(): " + method.asType());
         if (wrapped && soapStyle.equals(SOAPStyle.DOCUMENT)) {
             generateWrappers(method, webMethod);
         }
         generateExceptionBeans(method);
     }
     private boolean generateExceptionBeans(ExecutableElement method) {
         String beanPackage = packageName + PD_JAXWS_PACKAGE_PD.getValue();
         if (packageName.length() == 0)
             beanPackage = JAXWS_PACKAGE_PD.getValue();
         boolean beanGenerated = false;
         for (TypeMirror thrownType : method.getThrownTypes()) {
             TypeElement typeDecl = (TypeElement) ((DeclaredType) thrownType).asElement();
             if (typeDecl == null) {
                 builder.processError(WebserviceapMessages.WEBSERVICEAP_COULD_NOT_FIND_TYPEDECL(
                         thrownType.toString(), context.getRound()));
                 return false;
             }
             boolean tmp = generateExceptionBean(typeDecl, beanPackage);
             beanGenerated = beanGenerated || tmp;
         }
         return beanGenerated;
     }
     private boolean duplicateName(String name) {
         for (String str : wrapperNames) {
             if (str.equalsIgnoreCase(name))
         return true;
         }
         wrapperNames.add(name);
     return false;
     }
     private boolean generateWrappers(ExecutableElement method, WebMethod webMethod) {
         boolean isOneway = method.getAnnotation(Oneway.class) != null;
         String beanPackage = packageName + PD_JAXWS_PACKAGE_PD.getValue();
         if (packageName.length() == 0)
             beanPackage = JAXWS_PACKAGE_PD.getValue();
         Name methodName = method.getSimpleName();
         String operationName = builder.getOperationName(methodName);
         operationName = webMethod != null && webMethod.operationName().length() > 0 ?
                 webMethod.operationName() : operationName;
         String reqName = operationName;
         String resName = operationName + WebServiceConstants.RESPONSE.getValue();
         String reqNamespace = typeNamespace;
         String resNamespace = typeNamespace;
         String requestClassName = beanPackage + StringUtils.capitalize(method.getSimpleName().toString());
         RequestWrapper reqWrapper = method.getAnnotation(RequestWrapper.class);
         if (reqWrapper != null) {
             if (reqWrapper.className().length() > 0)
                 requestClassName = reqWrapper.className();
             if (reqWrapper.localName().length() > 0)
                 reqName = reqWrapper.localName();
             if (reqWrapper.targetNamespace().length() > 0)
                 reqNamespace = reqWrapper.targetNamespace();
         }
         builder.log("requestWrapper: "+requestClassName);
 ///// fix for wsgen CR 6442344
         File file = new File(DirectoryUtil.getOutputDirectoryFor(requestClassName, builder.getSourceDir()),
                 Names.stripQualifier(requestClassName) + GeneratorConstants.JAVA_SRC_SUFFIX.getValue());
         builder.getOptions().addGeneratedFile(file);
 //////////
         boolean canOverwriteRequest = builder.canOverWriteClass(requestClassName);
         if (!canOverwriteRequest) {
             builder.log("Class " + requestClassName + " exists. Not overwriting.");
         }
         if (duplicateName(requestClassName) && canOverwriteRequest) {
             builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_REQUEST_WRAPPER_BEAN_NAME_NOT_UNIQUE(
                     typeElement.getQualifiedName(), method.toString()));
         }
         String responseClassName = null;
         boolean canOverwriteResponse = canOverwriteRequest;
         if (!isOneway) {
             responseClassName = beanPackage+StringUtils.capitalize(method.getSimpleName().toString())+RESPONSE.getValue();
             ResponseWrapper resWrapper = method.getAnnotation(ResponseWrapper.class);
             if(resWrapper != null) {
                 if (resWrapper.className().length() > 0)
                     responseClassName = resWrapper.className();
                 if (resWrapper.localName().length() > 0)
                     resName = resWrapper.localName();
                 if (resWrapper.targetNamespace().length() > 0)
                     resNamespace = resWrapper.targetNamespace();
             }
             canOverwriteResponse = builder.canOverWriteClass(responseClassName);
             if (!canOverwriteResponse) {
                 builder.log("Class " + responseClassName + " exists. Not overwriting.");
             }
             if (duplicateName(responseClassName) && canOverwriteResponse) {
                 builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_RESPONSE_WRAPPER_BEAN_NAME_NOT_UNIQUE(
                         typeElement.getQualifiedName(), method.toString()));
             }
             file = new File(DirectoryUtil.getOutputDirectoryFor(responseClassName, builder.getSourceDir()),
                     Names.stripQualifier(responseClassName) + GeneratorConstants.JAVA_SRC_SUFFIX.getValue());
             builder.getOptions().addGeneratedFile(file);
         }
         //ArrayList<MemberInfo> reqMembers = new ArrayList<MemberInfo>();
         //ArrayList<MemberInfo> resMembers = new ArrayList<MemberInfo>();
         WrapperInfo reqWrapperInfo = new WrapperInfo(requestClassName);
         //reqWrapperInfo.setMembers(reqMembers);
         WrapperInfo resWrapperInfo = null;
         if (!isOneway) {
             resWrapperInfo = new WrapperInfo(responseClassName);
             //resWrapperInfo.setMembers(resMembers);
         }
         seiContext.setReqWrapperOperation(method, reqWrapperInfo);
         if (!isOneway)
             seiContext.setResWrapperOperation(method, resWrapperInfo);
         try {
             if (!canOverwriteRequest && !canOverwriteResponse) {
                 return false;
             }
             JDefinedClass reqCls = null;
             if (canOverwriteRequest) {
                 reqCls = getCMClass(requestClassName, CLASS);
             }
             JDefinedClass resCls = null;
             if (!isOneway && canOverwriteResponse) {
                 resCls = getCMClass(responseClassName, CLASS);
             }
             // XMLElement Declarations
             writeXmlElementDeclaration(reqCls, reqName,reqNamespace);
             writeXmlElementDeclaration(resCls, resName, resNamespace);
             List<MemberInfo> reqMembers = ap_generator.collectRequestBeanMembers(method);
             List<MemberInfo> resMembers = ap_generator.collectResponseBeanMembers(method);
             // XmlType
             writeXmlTypeDeclaration(reqCls, reqName, reqNamespace, reqMembers);
             writeXmlTypeDeclaration(resCls, resName, resNamespace, resMembers);
             // class members
             writeMembers(reqCls, reqMembers);
             writeMembers(resCls, resMembers);
         } catch (Exception e) {
             throw new ModelerException("modeler.nestedGeneratorError",e);
         }
         return true;
     }
 //    private List<Annotation> collectJAXBAnnotations(Declaration decl) {
 //        List<Annotation> jaxbAnnotation = new ArrayList<Annotation>();
 //        for(Class jaxbClass : jaxbAnns) {
 //            Annotation ann = decl.getAnnotation(jaxbClass);
 //            if (ann != null) {
 //                jaxbAnnotation.add(ann);
 //            }
 //        }
 //        return jaxbAnnotation;
 //    }
     private TypeMirror getSafeType(TypeMirror type) {
         return makeSafeVisitor.visit(type, builder.getProcessingEnvironment().getTypeUtils());
     }
     private JType getType(TypeMirror typeMirror) {
         String type = typeMirror.toString();
         try {
 //            System.out.println("typeName: "+typeName);
             return cm.parseType(type);
 //            System.out.println("type: "+type);
         } catch (ClassNotFoundException e) {
             return cm.ref(type);
         }
     }
     private void writeMembers(JDefinedClass cls, Collection<MemberInfo> members) {
         if (cls == null)
             return;
         for (MemberInfo memInfo : members) {
             JType type = getType(memInfo.getParamType());
             JFieldVar field = cls.field(JMod.PRIVATE, type, memInfo.getParamName());
             annotateParameterWithJaxbAnnotations(memInfo, field);
         }
         for (MemberInfo memInfo : members) {
             writeMember(cls, memInfo.getParamType(),
                     memInfo.getParamName());
         }
     }
     private void annotateParameterWithJaxbAnnotations(MemberInfo memInfo, JFieldVar field) {
         List<Annotation> jaxbAnnotations = memInfo.getJaxbAnnotations();
         for(Annotation ann : jaxbAnnotations) {
             if (ann instanceof XmlMimeType) {
                 JAnnotationUse jaxbAnn = field.annotate(XmlMimeType.class);
                 jaxbAnn.param("value", ((XmlMimeType)ann).value());
             } else if (ann instanceof XmlJavaTypeAdapter) {
                 JAnnotationUse jaxbAnn = field.annotate(XmlJavaTypeAdapter.class);
                 XmlJavaTypeAdapter ja = (XmlJavaTypeAdapter) ann;
                 try {
                     ja.value();
                     throw new AssertionError();
                 } catch (MirroredTypeException e) {
                     jaxbAnn.param("value",getType(e.getTypeMirror()));
                 }
                 // XmlJavaTypeAdapter.type() is for package only. No need to copy.
             } else if (ann instanceof XmlAttachmentRef) {
                 field.annotate(XmlAttachmentRef.class);
             } else if (ann instanceof XmlList){
                 field.annotate(XmlList.class);
             } else if (ann instanceof XmlElement) {
                 XmlElement elemAnn = (XmlElement)ann;
                 JAnnotationUse jAnn = field.annotate(XmlElement.class);
                 jAnn.param("name", elemAnn.name());
                 jAnn.param("namespace", elemAnn.namespace());
                 if (elemAnn.nillable()) {
                     jAnn.param("nillable", true);
                 }
                 if (elemAnn.required()) {
                      jAnn.param("required", true);
                 }
             } else {
                 throw new WebServiceException("SEI Parameter cannot have this JAXB annotation: " + ann);
             }
         }
     }
     protected JDefinedClass getCMClass(String className, com.sun.codemodel.internal.ClassType type) {
         JDefinedClass cls;
         try {
             cls = cm._class(className, type);
         } catch (com.sun.codemodel.internal.JClassAlreadyExistsException e){
             cls = cm._getClass(className);
         }
         return cls;
     }
     private boolean generateExceptionBean(TypeElement thrownDecl, String beanPackage) {
         if (!builder.isServiceException(thrownDecl.asType()))
             return false;
         String exceptionName = ClassNameInfo.getName(thrownDecl.getQualifiedName().toString());
         if (processedExceptions.contains(exceptionName))
             return false;
         processedExceptions.add(exceptionName);
         WebFault webFault = thrownDecl.getAnnotation(WebFault.class);
         String className = beanPackage+ exceptionName + BEAN.getValue();
         Collection<MemberInfo> members = ap_generator.collectExceptionBeanMembers(thrownDecl);
         boolean isWSDLException = isWSDLException(members, thrownDecl);
         String namespace = typeNamespace;
         String name = exceptionName;
         FaultInfo faultInfo;
         if (isWSDLException) {
             TypeMirror beanType =  getFaultInfoMember(members).getParamType();
             faultInfo = new FaultInfo(TypeMonikerFactory.getTypeMoniker(beanType), true);
             namespace = webFault.targetNamespace().length()>0 ?
                                webFault.targetNamespace() : namespace;
             name = webFault.name().length()>0 ?
                           webFault.name() : name;
             faultInfo.setElementName(new QName(namespace, name));
             seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);
             return false;
         }
         if (webFault != null) {
             namespace = webFault.targetNamespace().length()>0 ?
                         webFault.targetNamespace() : namespace;
             name = webFault.name().length()>0 ?
                    webFault.name() : name;
             className = webFault.faultBean().length()>0 ?
                         webFault.faultBean() : className;
         }
         JDefinedClass cls = getCMClass(className, CLASS);
         faultInfo = new FaultInfo(className, false);
         if (duplicateName(className)) {
             builder.processError(WebserviceapMessages.WEBSERVICEAP_METHOD_EXCEPTION_BEAN_NAME_NOT_UNIQUE(
                     typeElement.getQualifiedName(), thrownDecl.getQualifiedName()));
         }
         boolean canOverWriteBean = builder.canOverWriteClass(className);
         if (!canOverWriteBean) {
             builder.log("Class " + className + " exists. Not overwriting.");
             seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);
             return false;
         }
         if (seiContext.getExceptionBeanName(thrownDecl.getQualifiedName()) != null)
             return false;
         //write class comment - JAXWS warning
         JDocComment comment = cls.javadoc();
         for (String doc : GeneratorBase.getJAXWSClassComment(ToolVersion.VERSION.MAJOR_VERSION)) {
             comment.add(doc);
         }
         // XmlElement Declarations
         writeXmlElementDeclaration(cls, name, namespace);
         // XmlType Declaration
         //members = sortMembers(members);
         XmlType xmlType = thrownDecl.getAnnotation(XmlType.class);
         String xmlTypeName = (xmlType != null && !xmlType.name().equals("##default")) ? xmlType.name() : exceptionName;
         String xmlTypeNamespace = (xmlType != null && !xmlType.namespace().equals("##default")) ? xmlType.namespace() : typeNamespace;
         writeXmlTypeDeclaration(cls, xmlTypeName, xmlTypeNamespace, members);
         writeMembers(cls, members);
         seiContext.addExceptionBeanEntry(thrownDecl.getQualifiedName(), faultInfo, builder);
         return true;
     }
     protected boolean isWSDLException(Collection<MemberInfo> members, TypeElement thrownDecl) {
         WebFault webFault = thrownDecl.getAnnotation(WebFault.class);
         return webFault != null && members.size() == 2 && getFaultInfoMember(members) != null;
     }
     /*
      * Returns the corresponding MemberInfo for getFaultInfo()
      * method of an exception. Returns null, if that method is not there.
      */
     private MemberInfo getFaultInfoMember(Collection<MemberInfo> members) {
         for(MemberInfo member : members) {
             if (member.getParamName().equals(FAULT_INFO.getValue())) {
                 return member;
             }
         }
         return null;
     }
     private void writeXmlElementDeclaration(JDefinedClass cls, String elementName, String namespaceUri) {
        if (cls == null)
             return;
         JAnnotationUse xmlRootElementAnn = cls.annotate(XmlRootElement.class);
         xmlRootElementAnn.param("name", elementName);
         if (namespaceUri.length() > 0) {
             xmlRootElementAnn.param("namespace", namespaceUri);
         }
         JAnnotationUse xmlAccessorTypeAnn = cls.annotate(cm.ref(XmlAccessorType.class));
         xmlAccessorTypeAnn.param("value", XmlAccessType.FIELD);
     }
     private void writeXmlTypeDeclaration(JDefinedClass cls, String typeName, String namespaceUri,
                                          Collection<MemberInfo> members) {
         if (cls == null)
             return;
         JAnnotationUse xmlTypeAnn = cls.annotate(cm.ref(XmlType.class));
         xmlTypeAnn.param("name", typeName);
         xmlTypeAnn.param("namespace", namespaceUri);
         if (members.size() > 1) {
             JAnnotationArrayMember paramArray = xmlTypeAnn.paramArray("propOrder");
             for (MemberInfo memInfo : members) {
                 paramArray.param(memInfo.getParamName());
             }
         }
     }
     private void writeMember(JDefinedClass cls, TypeMirror paramType,
                              String paramName) {
         if (cls == null)
             return;
         String accessorName =BindingHelper.mangleNameToPropertyName(paramName);
         String getterPrefix = paramType.toString().equals("boolean")? "is" : "get";
         JType propType = getType(paramType);
         JMethod m = cls.method(JMod.PUBLIC, propType, getterPrefix+ accessorName);
         JDocComment methodDoc = m.javadoc();
         JCommentPart ret = methodDoc.addReturn();
         ret.add("returns "+propType.name());
         JBlock body = m.body();
         body._return( JExpr._this().ref(paramName) );
         m = cls.method(JMod.PUBLIC, cm.VOID, "set"+accessorName);
         JVar param = m.param(propType, paramName);
         methodDoc = m.javadoc();
         JCommentPart part = methodDoc.addParam(paramName);
         part.add("the value for the "+ paramName+" property");
         body = m.body();
         body.assign( JExpr._this().ref(paramName), param );
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/tools/internal/ws/processor/modeler/annotation/WebServiceWrapperGenerator.java@f50545b5e2f1 (annotated)

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