| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.axis2.jaxws.description.builder.converter; |
| |
| import org.apache.axis2.java.security.AccessController; |
| import org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite; |
| import org.apache.axis2.jaxws.description.builder.FieldDescriptionComposite; |
| import org.apache.axis2.jaxws.description.builder.HandlerChainAnnot; |
| import org.apache.axis2.jaxws.description.builder.MethodDescriptionComposite; |
| import org.apache.axis2.jaxws.description.builder.ParameterDescriptionComposite; |
| import org.apache.axis2.jaxws.description.builder.SoapBindingAnnot; |
| import org.apache.axis2.jaxws.description.builder.TMAnnotationComposite; |
| import org.apache.axis2.jaxws.description.builder.TMFAnnotationComposite; |
| import org.apache.axis2.jaxws.description.builder.WebServiceRefAnnot; |
| |
| import javax.jws.HandlerChain; |
| import javax.jws.soap.SOAPBinding; |
| import javax.xml.bind.annotation.XmlList; |
| import javax.xml.ws.WebServiceRef; |
| import java.lang.annotation.Annotation; |
| import java.lang.reflect.AnnotatedElement; |
| import java.lang.reflect.GenericArrayType; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.ParameterizedType; |
| import java.lang.reflect.Type; |
| import java.lang.reflect.WildcardType; |
| import java.security.PrivilegedAction; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| public class ConverterUtils { |
| |
| /** |
| * Helper method to retrieve the annotation specified by a certain <code>Class</code> |
| * |
| * @param annotationClass - <code>Class</code> the annotation <code>Class</code> |
| * @param element - <code>AnnotatedElement</code> - the element on which we are looking for |
| * the annotation (i.e. Class, Method, Field) |
| * @return - <code>Annotation</code> annotation represented by the given <code>Class</code> |
| */ |
| public static Annotation getAnnotation(final Class annotationClass, final AnnotatedElement element) { |
| return (Annotation) AccessController.doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| return element.getAnnotation(annotationClass); |
| } |
| }); |
| } |
| |
| /** |
| * Helper method to retrieve a list of all annotations that match the following |
| * conditions: |
| * |
| * - Annotations that extend the parameterized type T |
| * - Annotations that themselves are annotated with type T |
| * |
| * @param annotationClass |
| * @param element |
| * @return |
| */ |
| public static <T extends Annotation> List<Annotation> getAnnotations(final Class<T> annotationClass, final AnnotatedElement element) { |
| List<Annotation> matches = new ArrayList<Annotation>(); |
| Annotation[] annotations = null; |
| |
| // Get the complete list of annotations from the class that was provided. |
| annotations = (Annotation[]) AccessController.doPrivileged(new PrivilegedAction() { |
| public Object run() { |
| return element.getAnnotations(); |
| } |
| }); |
| |
| for (Annotation a: annotations) { |
| // If the annotation matches the parameter type we're looking |
| // for, add it to the list. |
| if (a.annotationType().isAnnotationPresent(annotationClass) || |
| annotationClass.isAssignableFrom(a.annotationType())) { |
| matches.add(a); |
| } |
| } |
| |
| return matches; |
| } |
| |
| /** |
| * This is a helper method to create a <code>HandlerChainAnnot</code> since the |
| * |
| * @param handlerChain - <code>HandlerChain</code> |
| * @return - <code>HandlerChainAnnot</code> |
| * @HandlerChain annotation may be present on a Type, Method, or Field. |
| */ |
| public static HandlerChainAnnot createHandlerChainAnnot(HandlerChain handlerChain) { |
| HandlerChainAnnot hcAnnot = HandlerChainAnnot.createHandlerChainAnnotImpl(); |
| hcAnnot.setFile(handlerChain.file()); |
| hcAnnot.setName(handlerChain.name()); |
| return hcAnnot; |
| } |
| |
| /** |
| * This is a helper method to create a <code>SoapBindingAnnot</code> since the |
| * |
| * @param soapBinding - <code>SOAPBinding</code> |
| * @return - <code>SoapBindingAnnot</code> |
| * @SOAPBinding annotation may be present on a Type or Method. |
| */ |
| public static SoapBindingAnnot createSoapBindingAnnot(SOAPBinding soapBinding) { |
| SoapBindingAnnot sbAnnot = SoapBindingAnnot.createSoapBindingAnnotImpl(); |
| sbAnnot.setParameterStyle(soapBinding.parameterStyle()); |
| sbAnnot.setStyle(soapBinding.style()); |
| sbAnnot.setUse(soapBinding.use()); |
| return sbAnnot; |
| } |
| |
| /** |
| * This is a helper method to create a <code>WebServiceRefAnnot</code> since the |
| * |
| * @param webServiceRef - <code>WebServiceRef</code> |
| * @return - <code>WebServiceRefAnnot</code> |
| * @WebServiceRef annotation may be present on a Type, Method, or Field. |
| */ |
| public static WebServiceRefAnnot createWebServiceRefAnnot(WebServiceRef webServiceRef) { |
| WebServiceRefAnnot wsrAnnot = WebServiceRefAnnot.createWebServiceRefAnnotImpl(); |
| wsrAnnot.setMappedName(webServiceRef.mappedName()); |
| wsrAnnot.setName(webServiceRef.name()); |
| wsrAnnot.setType(webServiceRef.type()); |
| wsrAnnot.setValue(webServiceRef.value()); |
| wsrAnnot.setWsdlLocation(webServiceRef.wsdlLocation()); |
| return wsrAnnot; |
| } |
| |
| /** |
| * This method is use to attach @HandlerChain annotation data to a composite object. |
| * |
| * @param composite - <code>TMFAnnotationComposite</code> |
| * @param annotatedElement - <code>AnnotatedElement</code> |
| */ |
| public static void attachHandlerChainAnnotation(TMFAnnotationComposite composite, |
| AnnotatedElement annotatedElement) { |
| HandlerChain handlerChain = (HandlerChain)ConverterUtils.getAnnotation( |
| HandlerChain.class, annotatedElement); |
| if (handlerChain != null) { |
| HandlerChainAnnot hcAnnot = ConverterUtils.createHandlerChainAnnot( |
| handlerChain); |
| composite.setHandlerChainAnnot(hcAnnot); |
| } |
| } |
| |
| /** |
| * This method is use to attach @SOAPBinding annotation data to a composite object. |
| * |
| * @param composite - <code>TMAnnotationComposite</code> |
| * @param annotatedElement - <code>AnnotatedElement</code> |
| */ |
| public static void attachSoapBindingAnnotation(TMAnnotationComposite composite, |
| AnnotatedElement annotatedElement) { |
| SOAPBinding soapBinding = (SOAPBinding)ConverterUtils.getAnnotation( |
| SOAPBinding.class, annotatedElement); |
| if (soapBinding != null) { |
| SoapBindingAnnot sbAnnot = ConverterUtils.createSoapBindingAnnot(soapBinding); |
| composite.setSoapBindingAnnot(sbAnnot); |
| } |
| } |
| |
| /** |
| * This method is use to attach @WebServiceRef annotation data to a composite object. |
| * |
| * @param composite - <code>TMFAnnotationComposite</code> |
| * @param annotatedElement - <code>AnnotatedElement</code> |
| */ |
| public static void attachWebServiceRefAnnotation(TMFAnnotationComposite composite, |
| AnnotatedElement annotatedElement) { |
| WebServiceRef webServiceRef = (WebServiceRef)ConverterUtils.getAnnotation( |
| WebServiceRef.class, annotatedElement); |
| if (webServiceRef != null) { |
| WebServiceRefAnnot wsrAnnot = ConverterUtils.createWebServiceRefAnnot( |
| webServiceRef); |
| composite.setWebServiceRefAnnot(wsrAnnot); |
| } |
| } |
| |
| /** This method will add FieldDescriptionComposite objects to a DescriptionBuilderComposite */ |
| public static void attachFieldDescriptionComposites(DescriptionBuilderComposite |
| composite, List<FieldDescriptionComposite> fdcList) { |
| for (FieldDescriptionComposite fdc : fdcList) { |
| composite.addFieldDescriptionComposite(fdc); |
| } |
| } |
| |
| /** This method will add MethodDescriptionComposite objects to a DescriptionBuilderComposite */ |
| public static void attachMethodDescriptionComposites(DescriptionBuilderComposite |
| composite, List<MethodDescriptionComposite> mdcList) { |
| for (MethodDescriptionComposite mdc : mdcList) { |
| composite.addMethodDescriptionComposite(mdc); |
| mdc.setDescriptionBuilderCompositeRef(composite); |
| } |
| } |
| |
| /** This method will add ParameterDescriptionComposite objects to a MethodDescriptionComposite */ |
| public static void attachParameterDescriptionComposites(List |
| <ParameterDescriptionComposite> pdcList, MethodDescriptionComposite mdc) { |
| for (ParameterDescriptionComposite pdc : pdcList) { |
| mdc.addParameterDescriptionComposite(pdc); |
| pdc.setMethodDescriptionCompositeRef(mdc); |
| } |
| } |
| |
| /** |
| * This method will check to see if a method's declaring class is the Object class. |
| * |
| * @param method - <code>Method</code> |
| * @return - <code>boolean</code> |
| */ |
| public static boolean isInherited(Method method, String declaringClass) { |
| if (method.getDeclaringClass().getName().equals(declaringClass)) { |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * This method will construct a <code>String</code> that represents the |
| * full type of a parameterized variable. |
| * @param pt - <code>ParameterizedType</code> |
| * @param paramType - <code>String</code> |
| * @return - <code>String</code> |
| */ |
| public static String getFullType(ParameterizedType pt, String paramType) { |
| if (pt.getRawType() instanceof Class) { |
| Class rawClass = (Class)pt.getRawType(); |
| paramType = paramType + rawClass.getName(); |
| } |
| Type[] genericTypes = pt.getActualTypeArguments(); |
| if (genericTypes.length > 0) { |
| paramType = paramType + "<"; |
| for (int i = 0; i < genericTypes.length; i++) { |
| Type type = genericTypes[i]; |
| paramType = getType(type, paramType); |
| |
| // Set string for more parameters OR close the generic if this is the last one. |
| if (i != genericTypes.length - 1) { |
| paramType = paramType + ", "; |
| } else { |
| paramType = paramType + ">"; |
| } |
| |
| } |
| } |
| return paramType; |
| } |
| |
| public static String getType(Type type, String paramType) { |
| if (type instanceof Class) { |
| paramType = paramType + ((Class)type).getName(); |
| } else if (type instanceof ParameterizedType) { |
| paramType = getFullType((ParameterizedType)type, paramType); |
| } else if (type instanceof WildcardType) { |
| paramType = paramType + "?"; |
| } else if (type instanceof GenericArrayType) { |
| paramType = getType(((GenericArrayType)type).getGenericComponentType(), paramType) + "[]"; |
| } |
| return paramType; |
| } |
| |
| /** |
| * This method will search array of parameter annotations for the presence of the @XmlList |
| * annotation. |
| */ |
| public static boolean hasXmlListAnnotation(Annotation[] annotations) { |
| for(Annotation annotation : annotations) { |
| if(annotation.annotationType() == XmlList.class) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |