| /* |
| * 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.wink.common.model.wadl; |
| |
| import java.lang.annotation.Annotation; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import javax.ws.rs.DefaultValue; |
| import javax.ws.rs.FormParam; |
| import javax.ws.rs.HeaderParam; |
| import javax.ws.rs.MatrixParam; |
| import javax.ws.rs.Path; |
| import javax.ws.rs.PathParam; |
| import javax.ws.rs.QueryParam; |
| import javax.ws.rs.core.MediaType; |
| import javax.xml.namespace.QName; |
| |
| import org.apache.wink.common.DynamicResource; |
| import org.apache.wink.common.internal.registry.Injectable; |
| import org.apache.wink.common.internal.registry.Injectable.ParamType; |
| import org.apache.wink.common.internal.registry.metadata.ClassMetadata; |
| import org.apache.wink.common.internal.registry.metadata.MethodMetadata; |
| import org.apache.wink.common.internal.registry.metadata.ResourceMetadataCollector; |
| import org.apache.wink.common.internal.uritemplate.JaxRsUriTemplateProcessor; |
| import org.apache.wink.common.internal.uritemplate.UriTemplateProcessor; |
| |
| /** |
| * @Path("/sfdsf"); public class MyResource { |
| * @Context javax.ws.rs.core.Application app; |
| * @OPTIONS public org.apache.wink.common.model.wadl.Application getWADL() { |
| * return new WADLGenerator().generate(app.getClasses()); } } |
| */ |
| public class WADLGenerator { |
| |
| private static final String XML_SCHEMA_NS = "http://www.w3.org/2001/XMLSchema"; |
| |
| public Application generate(String baseURI, Set<Class<?>> classes) { |
| /* |
| * the idea is that classes comes from the Application subclass |
| */ |
| Application app = new Application(); |
| if (classes == null || classes.isEmpty()) { |
| return app; |
| } |
| |
| Resources resources = new Resources(); |
| resources.setBase(baseURI); |
| |
| Set<ClassMetadata> metadataSet = buildClassMetdata(classes); |
| resources.getResource().addAll(buildResources(metadataSet)); |
| app.getResources().add(resources); |
| return app; |
| } |
| |
| /* package */Set<ClassMetadata> buildClassMetdata(Set<Class<?>> classes) { |
| Set<ClassMetadata> metadataSet = new HashSet<ClassMetadata>(classes.size()); |
| for (Class<?> c : classes) { |
| if (!isResource(c)) { |
| /* not a resource, so skip it */ |
| continue; |
| } |
| |
| ClassMetadata metadata = ResourceMetadataCollector.collectMetadata(c); |
| metadataSet.add(metadata); |
| } |
| |
| return metadataSet; |
| } |
| |
| /* package */Set<Resource> buildResources(Set<ClassMetadata> metadataSet) { |
| Set<Resource> s = new HashSet<Resource>(metadataSet.size()); |
| for (ClassMetadata metadata : metadataSet) { |
| Resource r = buildResource(metadata); |
| s.add(r); |
| } |
| |
| return s; |
| } |
| |
| /* package */Resource buildResource(ClassMetadata metadata) { |
| Resource r = new Resource(); |
| |
| if (metadata != null) { |
| Class<?> resClass = metadata.getResourceClass(); |
| if (resClass != null) { |
| WADLDoc d = resClass.getAnnotation(WADLDoc.class); |
| if (d != null) { |
| r.getDoc().add(getDocument(d)); |
| } |
| } |
| } |
| |
| /* set the path */ |
| String path = metadata.getPath(); |
| |
| if (path == null) { |
| Class<?> resClass = metadata.getResourceClass(); |
| if (DynamicResource.class.isAssignableFrom(resClass)) { |
| try { |
| DynamicResource dynRes = (DynamicResource)resClass.newInstance(); |
| path = dynRes.getPath(); |
| } catch (Exception e) { |
| // Drop through and look for @Path annotation. |
| } |
| } |
| } |
| |
| UriTemplateProcessor processor = JaxRsUriTemplateProcessor.newNormalizedInstance(path); |
| String pathStr = processor.getTemplate(); |
| for (String var : processor.getVariableNames()) { |
| pathStr = pathStr.replaceAll("\\{(\\s)*" + var + "(\\s)*:.*\\}", "{" + var + "}"); |
| } |
| r.setPath(pathStr); |
| |
| List<Object> methodOrSubresource = r.getMethodOrResource(); |
| List<Param> resourceParams = r.getParam(); |
| |
| List<MethodMetadata> methodMetadata = metadata.getResourceMethods(); |
| |
| if (methodMetadata != null && !methodMetadata.isEmpty()) { |
| for (MethodMetadata methodMeta : methodMetadata) { |
| Method m = buildMethod(metadata, methodMeta); |
| methodOrSubresource.add(m); |
| |
| /* also scan for all the path and matrix parameters */ |
| List<Injectable> params = methodMeta.getFormalParameters(); |
| if (params != null && params.size() > 0) { |
| for (Injectable p : params) { |
| Param param = null; |
| boolean isUnique = true; |
| switch (p.getParamType()) { |
| case QUERY: |
| /* do nothing */ |
| break; |
| case HEADER: |
| /* do nothing */ |
| break; |
| case ENTITY: |
| /* do nothing */ |
| break; |
| case COOKIE: |
| /* not supported in WADL */ |
| break; |
| case FORM: |
| /* should show up in the representation instead */ |
| break; |
| case PATH: |
| param = buildParam(p); |
| for (Param rParam : resourceParams) { |
| if (param.getName() != null && param.getName().equals(rParam |
| .getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| resourceParams.add(param); |
| } |
| break; |
| case MATRIX: |
| param = buildParam(p); |
| for (Param rParam : resourceParams) { |
| if (param.getName() != null && param.getName().equals(rParam |
| .getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| resourceParams.add(param); |
| } |
| break; |
| case CONTEXT: |
| /* do nothing */ |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * list the class level parameters |
| */ |
| List<Injectable> fields = metadata.getInjectableFields(); |
| if (fields != null) { |
| for (Injectable p : metadata.getInjectableFields()) { |
| Param param = null; |
| boolean isUnique = true; |
| |
| switch (p.getParamType()) { |
| case QUERY: |
| resourceParams.add(buildParam(p)); |
| break; |
| case HEADER: |
| resourceParams.add(buildParam(p)); |
| break; |
| case ENTITY: |
| /* do nothing */ |
| break; |
| case COOKIE: |
| /* not supported in WADL */ |
| break; |
| case FORM: |
| /* should show up in the representation instead */ |
| break; |
| case PATH: |
| param = buildParam(p); |
| for (Param rParam : resourceParams) { |
| if (param.getName() != null && param.getName().equals(rParam.getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| resourceParams.add(param); |
| } |
| break; |
| case MATRIX: |
| param = buildParam(p); |
| for (Param rParam : resourceParams) { |
| if (param.getName() != null && param.getName().equals(rParam.getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| resourceParams.add(param); |
| } |
| break; |
| case CONTEXT: |
| /* do nothing */ |
| break; |
| } |
| } |
| } |
| |
| /* |
| * list subresource methods |
| */ |
| methodMetadata = metadata.getSubResourceMethods(); |
| if (methodMetadata != null && !methodMetadata.isEmpty()) { |
| for (MethodMetadata methodMeta : methodMetadata) { |
| Resource subRes = new Resource(); |
| Method m = buildMethod(metadata, methodMeta); |
| subRes.getMethodOrResource().add(m); |
| subRes.setPath(methodMeta.getPath()); |
| methodOrSubresource.add(subRes); |
| List<Param> subResParams = subRes.getParam(); |
| /* also scan for all the path and matrix parameters */ |
| List<Injectable> params = methodMeta.getFormalParameters(); |
| if (params != null && params.size() > 0) { |
| for (Injectable p : params) { |
| Param param = null; |
| boolean isUnique = true; |
| |
| switch (p.getParamType()) { |
| case QUERY: |
| /* do nothing */ |
| break; |
| case HEADER: |
| /* do nothing */ |
| break; |
| case ENTITY: |
| /* do nothing */ |
| break; |
| case COOKIE: |
| /* not supported in WADL */ |
| break; |
| case FORM: |
| /* should show up in the representation instead */ |
| break; |
| case PATH: |
| param = buildParam(p); |
| for (Param rParam : subResParams) { |
| if (param.getName() != null && param.getName().equals(rParam |
| .getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| subRes.getParam().add(param); |
| } |
| break; |
| case MATRIX: |
| param = buildParam(p); |
| for (Param rParam : subResParams) { |
| if (param.getName() != null && param.getName().equals(rParam |
| .getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| subRes.getParam().add(param); |
| } |
| break; |
| case CONTEXT: |
| /* do nothing */ |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /* |
| * list subresource locators |
| */ |
| methodMetadata = metadata.getSubResourceLocators(); |
| if (methodMetadata != null && !methodMetadata.isEmpty()) { |
| for (MethodMetadata methodMeta : methodMetadata) { |
| Resource subRes = new Resource(); |
| subRes.setPath(methodMeta.getPath()); |
| |
| if (methodMeta != null) { |
| java.lang.reflect.Method reflMethod = methodMeta.getReflectionMethod(); |
| if (reflMethod != null) { |
| WADLDoc d = reflMethod.getAnnotation(WADLDoc.class); |
| if (d != null) { |
| subRes.getDoc().add(getDocument(d)); |
| } |
| } |
| } |
| |
| methodOrSubresource.add(subRes); |
| |
| /* also scan for all the path and matrix parameters */ |
| List<Injectable> params = methodMeta.getFormalParameters(); |
| List<Param> subResParams = subRes.getParam(); |
| if (params != null && params.size() > 0) { |
| for (Injectable p : params) { |
| Param param = null; |
| boolean isUnique = true; |
| |
| switch (p.getParamType()) { |
| case QUERY: |
| param = buildParam(p); |
| for (Param rParam : subResParams) { |
| if (param.getName() != null && param.getName().equals(rParam |
| .getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| subRes.getParam().add(param); |
| } |
| break; |
| case HEADER: |
| param = buildParam(p); |
| for (Param rParam : subResParams) { |
| if (param.getName() != null && param.getName().equals(rParam |
| .getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| subRes.getParam().add(param); |
| } |
| break; |
| case ENTITY: |
| /* do nothing */ |
| break; |
| case COOKIE: |
| /* not supported in WADL */ |
| break; |
| case FORM: |
| /* should show up in the representation instead */ |
| break; |
| case PATH: |
| param = buildParam(p); |
| for (Param rParam : subResParams) { |
| if (param.getName() != null && param.getName().equals(rParam |
| .getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| subRes.getParam().add(param); |
| } |
| break; |
| case MATRIX: |
| param = buildParam(p); |
| for (Param rParam : subResParams) { |
| if (param.getName() != null && param.getName().equals(rParam |
| .getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| subRes.getParam().add(param); |
| } |
| break; |
| case CONTEXT: |
| /* do nothing */ |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| return r; |
| } |
| |
| /* package */Method buildMethod(ClassMetadata classMetadata, MethodMetadata metadata) { |
| Method m = new Method(); |
| m.setName(metadata.getHttpMethod()); |
| |
| java.lang.reflect.Method reflMethod = metadata.getReflectionMethod(); |
| if (reflMethod != null) { |
| WADLDoc d = reflMethod.getAnnotation(WADLDoc.class); |
| if (d != null) { |
| m.getDoc().add(getDocument(d)); |
| } |
| } |
| |
| Request r = buildRequest(classMetadata, metadata); |
| if (r != null) { |
| m.setRequest(r); |
| } |
| |
| List<Response> resp = buildResponse(metadata); |
| if (resp != null) { |
| m.getResponse().addAll(resp); |
| } |
| return m; |
| } |
| |
| /* package */Request buildRequest(ClassMetadata classMetadata, MethodMetadata metadata) { |
| Request r = null; |
| |
| List<Injectable> params = metadata.getFormalParameters(); |
| if (params != null && params.size() > 0) { |
| if (r == null) { |
| r = new Request(); |
| } |
| boolean hasValidParams = false; |
| List<Param> requestParams = r.getParam(); |
| for (Injectable p : params) { |
| Param param = null; |
| boolean isUnique = true; |
| switch (p.getParamType()) { |
| case QUERY: |
| hasValidParams = true; |
| param = buildParam(p); |
| for (Param rParam : requestParams) { |
| if (param.getName() != null && param.getName().equals(rParam.getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| requestParams.add(buildParam(p)); |
| } |
| |
| break; |
| case HEADER: |
| hasValidParams = true; |
| param = buildParam(p); |
| for (Param rParam : requestParams) { |
| if (param.getName() != null && param.getName().equals(rParam.getName()) |
| && rParam.getStyle().equals(param.getStyle())) { |
| isUnique = false; |
| } |
| } |
| if (isUnique) { |
| requestParams.add(buildParam(p)); |
| } |
| break; |
| case ENTITY: |
| hasValidParams = true; |
| |
| Annotation[] anns = p.getAnnotations(); |
| if (anns != null && anns.length > 0) { |
| for (Annotation a : anns) { |
| if (WADLDoc.class.equals(a.annotationType())) { |
| WADLDoc d = (WADLDoc)a; |
| r.getDoc().add(getDocument(d)); |
| } |
| } |
| } |
| |
| /* need to build the representation */ |
| Set<Representation> representations = |
| buildIncomingRepresentation(classMetadata, metadata, p); |
| if (representations != null) |
| r.getRepresentation().addAll(representations); |
| break; |
| case COOKIE: |
| /* not supported in WADL */ |
| break; |
| case FORM: |
| /* should show up in the representation instead */ |
| break; |
| case PATH: |
| /* should show up in the containing resource */ |
| break; |
| case MATRIX: |
| /* should show up in the containing resource */ |
| break; |
| case CONTEXT: |
| /* do nothing */ |
| break; |
| } |
| } |
| if (!hasValidParams) { |
| r = null; |
| } |
| } |
| |
| return r; |
| } |
| |
| /* package */Param buildParam(Injectable paramMetadata) { |
| Param p = null; |
| ParamType pt = paramMetadata.getParamType(); |
| Annotation[] annotations = paramMetadata.getAnnotations(); |
| switch (pt) { |
| case HEADER: |
| p = new Param(); |
| p.setStyle(ParamStyle.HEADER); |
| if (annotations != null) { |
| for (Annotation a : annotations) { |
| if (HeaderParam.class.equals(a.annotationType())) { |
| HeaderParam paramAnn = (HeaderParam)a; |
| p.setName(paramAnn.value()); |
| } |
| } |
| } |
| break; |
| case MATRIX: |
| p = new Param(); |
| p.setStyle(ParamStyle.MATRIX); |
| for (Annotation a : annotations) { |
| if (MatrixParam.class.equals(a.annotationType())) { |
| MatrixParam paramAnn = (MatrixParam)a; |
| p.setName(paramAnn.value()); |
| } |
| } |
| break; |
| case PATH: |
| p = new Param(); |
| p.setStyle(ParamStyle.TEMPLATE); |
| for (Annotation a : annotations) { |
| if (PathParam.class.equals(a.annotationType())) { |
| PathParam paramAnn = (PathParam)a; |
| p.setName(paramAnn.value()); |
| } |
| } |
| break; |
| case QUERY: |
| p = new Param(); |
| p.setStyle(ParamStyle.QUERY); |
| for (Annotation a : annotations) { |
| if (QueryParam.class.equals(a.annotationType())) { |
| QueryParam paramAnn = (QueryParam)a; |
| p.setName(paramAnn.value()); |
| } |
| } |
| break; |
| case FORM: |
| p = new Param(); |
| p.setStyle(ParamStyle.QUERY); |
| for (Annotation a : annotations) { |
| if (FormParam.class.equals(a.annotationType())) { |
| FormParam paramAnn = (FormParam)a; |
| p.setName(paramAnn.value()); |
| } |
| } |
| break; |
| case CONTEXT: |
| break; |
| case COOKIE: |
| break; |
| case ENTITY: |
| break; |
| } |
| |
| if (p == null) { |
| /* |
| * The paramtype was never set so return null. This might have been |
| * some other type of injectable that shouldn't be created as a |
| * Param. This is a preventive measure. |
| */ |
| return null; |
| } |
| |
| Class<?> memberType = paramMetadata.getType(); |
| if (memberType.equals(int.class) || memberType.equals(Integer.class)) { |
| p.setType(new QName(XML_SCHEMA_NS, "int")); |
| } else if (memberType.equals(float.class) || memberType.equals(Float.class)) { |
| p.setType(new QName(XML_SCHEMA_NS, "float")); |
| } else if (memberType.equals(long.class) || memberType.equals(Long.class)) { |
| p.setType(new QName(XML_SCHEMA_NS, "long")); |
| } else if (memberType.equals(boolean.class) || memberType.equals(Boolean.class)) { |
| p.setType(new QName(XML_SCHEMA_NS, "boolean")); |
| } else if (memberType.equals(short.class) || memberType.equals(Short.class)) { |
| p.setType(new QName(XML_SCHEMA_NS, "short")); |
| } else if (memberType.equals(double.class) || memberType.equals(Double.class)) { |
| p.setType(new QName(XML_SCHEMA_NS, "double")); |
| } else if (memberType.equals(byte.class) || memberType.equals(Byte.class)) { |
| p.setType(new QName(XML_SCHEMA_NS, "byte")); |
| } |
| |
| for (Annotation a : annotations) { |
| if (DefaultValue.class.equals(a.annotationType())) { |
| DefaultValue paramAnn = (DefaultValue)a; |
| p.setDefault(paramAnn.value()); |
| } |
| |
| if (WADLDoc.class.equals(a.annotationType())) { |
| WADLDoc d = (WADLDoc)a; |
| p.getDoc().add(getDocument(d)); |
| } |
| } |
| |
| return p; |
| } |
| |
| /* package */Set<Representation> buildIncomingRepresentation(ClassMetadata classMetadata, |
| MethodMetadata methodMetadata, |
| Injectable metadata) { |
| if (methodMetadata == null) { |
| return null; |
| } |
| |
| if (metadata != null && metadata.getParamType() != ParamType.ENTITY) { |
| throw new IllegalArgumentException("Parameter data is not for an entity."); |
| } |
| |
| /* |
| * first check all the consumes |
| */ |
| Set<MediaType> consumesMT = methodMetadata.getConsumes(); |
| Set<Representation> reps = null; |
| if (consumesMT != null && !consumesMT.isEmpty()) { |
| reps = new HashSet<Representation>(); |
| for (MediaType mt : consumesMT) { |
| Representation r = new Representation(); |
| r.setMediaType(mt.toString()); |
| |
| /* |
| * if the representation is a special case, we need to build for |
| * it |
| */ |
| /* |
| * special cases include application/xml, text/xml; should set |
| * the element attribute |
| */ |
| List<Param> params = new ArrayList<Param>(); |
| if (mt.isCompatible(MediaType.APPLICATION_FORM_URLENCODED_TYPE) || mt |
| .isCompatible(MediaType.MULTIPART_FORM_DATA_TYPE)) { |
| List<Injectable> injectables = methodMetadata.getFormalParameters(); |
| if (injectables != null) { |
| for (Injectable i : injectables) { |
| if (ParamType.FORM.equals(i.getParamType())) { |
| params.add(buildParam(i)); |
| } |
| } |
| } |
| |
| /* |
| * should we scan the class metadata too? FormParams aren't |
| * required to be supported in other places than the |
| * resource method parameters |
| */ |
| if (!params.isEmpty()) { |
| r.getParam().addAll(params); |
| } |
| } |
| reps.add(r); |
| } |
| } else { |
| if (metadata == null) { |
| return null; |
| } |
| |
| /* |
| * there aren't any consumes so we can't look for that but maybe we |
| * can look at the Providers registry and find all the relevant |
| * media types there |
| */ |
| } |
| |
| return reps; |
| } |
| |
| /* package */List<Response> buildResponse(MethodMetadata metadata) { |
| if (metadata == null) { |
| return null; |
| } |
| Response r = null; |
| // Set<MediaType> produces = metadata.getProduces(); |
| Set<Representation> representations = buildOutgoingRepresentation(metadata, null); |
| if (representations != null && !representations.isEmpty()) { |
| r = new Response(); |
| r.getRepresentation().addAll(representations); |
| } |
| |
| java.lang.reflect.Method m = metadata.getReflectionMethod(); |
| if (Void.TYPE.equals(m.getReturnType())) { |
| if (r == null) { |
| r = new Response(); |
| } |
| r.getStatus().add(Long.valueOf(204)); |
| } else if (!javax.ws.rs.core.Response.class.isAssignableFrom(m.getReturnType())) { |
| if (r == null) { |
| r = new Response(); |
| } |
| r.getStatus().add(Long.valueOf(200)); |
| } |
| |
| return Collections.singletonList(r); |
| } |
| |
| /* package */Set<Representation> buildOutgoingRepresentation(MethodMetadata methodMetadata, |
| Class<?> returnType) { |
| if (methodMetadata == null) { |
| return null; |
| } |
| |
| /* |
| * first check all the consumes |
| */ |
| Set<MediaType> producesMT = methodMetadata.getProduces(); |
| Set<Representation> reps = null; |
| if (producesMT != null && !producesMT.isEmpty()) { |
| reps = new HashSet<Representation>(); |
| for (MediaType mt : producesMT) { |
| Representation r = new Representation(); |
| r.setMediaType(mt.toString()); |
| |
| /* |
| * if the representation is a special case, we need to build for |
| * it |
| */ |
| /* |
| * TODO: special cases include application/xml, text/xml; should |
| * set the element attribute |
| */ |
| reps.add(r); |
| } |
| } else { |
| /* |
| * there aren't any produces so we can't look for that but maybe we |
| * can look at the Providers registry and find all the relevant |
| * media types there |
| */ |
| } |
| |
| return reps; |
| } |
| |
| /* package */Doc getDocument(WADLDoc desc) { |
| Doc d = new Doc(); |
| d.setTitle(desc.value()); |
| if (!"".equals(desc.content())) { |
| d.getContent().add(desc.content()); |
| } |
| return d; |
| } |
| |
| /* |
| * Customized isResource method so it accepts interfaces. |
| */ |
| protected boolean isResource(Class<?> cls) { |
| if (ResourceMetadataCollector.isDynamicResource(cls)) { |
| return true; |
| } |
| |
| if (cls.getAnnotation(Path.class) != null) { |
| return true; |
| } |
| |
| Class<?> declaringClass = cls; |
| |
| while (!declaringClass.equals(Object.class)) { |
| // try a superclass |
| Class<?> superclass = declaringClass.getSuperclass(); |
| if (superclass.getAnnotation(Path.class) != null) { |
| return true; |
| } |
| |
| // try interfaces |
| Class<?>[] interfaces = declaringClass.getInterfaces(); |
| for (Class<?> interfaceClass : interfaces) { |
| if (interfaceClass.getAnnotation(Path.class) != null) { |
| return true; |
| } |
| } |
| declaringClass = declaringClass.getSuperclass(); |
| } |
| return false; |
| } |
| |
| } |
