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

 /*

  * 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.codemodel.internal;

 import java.lang.reflect.InvocationHandler;

 import java.lang.reflect.Method;

 import java.lang.reflect.Proxy;

 import java.lang.reflect.Type;

 import java.lang.reflect.ParameterizedType;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.annotation.Annotation;

 import java.util.Map;

 import java.util.HashMap;

 /**

  * Dynamically implements the typed annotation writer interfaces.

  *

  * @author Kohsuke Kawaguchi

  */

 class TypedAnnotationWriter<A extends Annotation,W extends JAnnotationWriter<A>>

     implements InvocationHandler, JAnnotationWriter<A> {

     /**

      * This is what we are writing to.

      */

     private final JAnnotationUse use;

     /**

      * The annotation that we are writing.

      */

     private final Class<A> annotation;

     /**

      * The type of the writer.

      */

     private final Class<W> writerType;

     /**

      * Keeps track of writers for array members.

      * Lazily created.

      */

     private Map<String,JAnnotationArrayMember> arrays;

     public TypedAnnotationWriter(Class<A> annotation, Class<W> writer, JAnnotationUse use) {

         this.annotation = annotation;

         this.writerType = writer;

         this.use = use;

     }

     public JAnnotationUse getAnnotationUse() {

         return use;

     }

     public Class<A> getAnnotationType() {

         return annotation;

     }

     @SuppressWarnings("unchecked")

         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

         if(method.getDeclaringClass()==JAnnotationWriter.class) {

             try {

                 return method.invoke(this,args);

             } catch (InvocationTargetException e) {

                 throw e.getTargetException();

             }

         }

         String name = method.getName();

         Object arg=null;

         if(args!=null && args.length>0)

             arg = args[0];

         // check how it's defined on the annotation

         Method m = annotation.getDeclaredMethod(name);

         Class<?> rt = m.getReturnType();

         // array value

         if(rt.isArray()) {

             return addArrayValue(proxy,name,rt.getComponentType(),method.getReturnType(),arg);

         }

         // sub annotation

         if(Annotation.class.isAssignableFrom(rt)) {

             Class<? extends Annotation> r = (Class<? extends Annotation>)rt;

             return new TypedAnnotationWriter(

                 r,method.getReturnType(),use.annotationParam(name,r)).createProxy();

         }

         // scalar value

         if(arg instanceof JType) {

             JType targ = (JType) arg;

             checkType(Class.class,rt);

             if(m.getDefaultValue()!=null) {

                 // check the default

                 if(targ.equals(targ.owner().ref((Class)m.getDefaultValue())))

                     return proxy;   // defaulted

             }

             use.param(name,targ);

             return proxy;

         }

         // other Java built-in types

         checkType(arg.getClass(),rt);

         if(m.getDefaultValue()!=null && m.getDefaultValue().equals(arg))

             // defaulted. no need to write out.

             return proxy;

         if(arg instanceof String) {

             use.param(name,(String)arg);

             return proxy;

         }

         if(arg instanceof Boolean) {

             use.param(name,(Boolean)arg);

             return proxy;

         }

         if(arg instanceof Integer) {

             use.param(name,(Integer)arg);

             return proxy;

         }

         if(arg instanceof Class) {

             use.param(name,(Class)arg);

             return proxy;

         }

         if(arg instanceof Enum) {

             use.param(name,(Enum)arg);

             return proxy;

         }

         throw new IllegalArgumentException("Unable to handle this method call "+method.toString());

     }

     @SuppressWarnings("unchecked")

         private Object addArrayValue(Object proxy,String name, Class itemType, Class expectedReturnType, Object arg) {

         if(arrays==null)

             arrays = new HashMap<String,JAnnotationArrayMember>();

         JAnnotationArrayMember m = arrays.get(name);

         if(m==null) {

             m = use.paramArray(name);

             arrays.put(name,m);

         }

         // sub annotation

         if(Annotation.class.isAssignableFrom(itemType)) {

             Class<? extends Annotation> r = (Class<? extends Annotation>)itemType;

             if(!JAnnotationWriter.class.isAssignableFrom(expectedReturnType))

                 throw new IllegalArgumentException("Unexpected return type "+expectedReturnType);

             return new TypedAnnotationWriter(r,expectedReturnType,m.annotate(r)).createProxy();

         }

         // primitive

         if(arg instanceof JType) {

             checkType(Class.class,itemType);

             m.param((JType)arg);

             return proxy;

         }

         checkType(arg.getClass(),itemType);

         if(arg instanceof String) {

             m.param((String)arg);

             return proxy;

         }

         if(arg instanceof Boolean) {

             m.param((Boolean)arg);

             return proxy;

         }

         if(arg instanceof Integer) {

             m.param((Integer)arg);

             return proxy;

         }

         if(arg instanceof Class) {

             m.param((Class)arg);

             return proxy;

         }

         // TODO: enum constant. how should we handle it?

         throw new IllegalArgumentException("Unable to handle this method call ");

     }

     /**

      * Check if the type of the argument matches our expectation.

      * If not, report an error.

      */

     private void checkType(Class<?> actual, Class<?> expected) {

         if(expected==actual || expected.isAssignableFrom(actual))

             return; // no problem

         if( expected==JCodeModel.boxToPrimitive.get(actual) )

             return; // no problem

         throw new IllegalArgumentException("Expected "+expected+" but found "+actual);

     }

     /**

      * Creates a proxy and returns it.

      */

     @SuppressWarnings("unchecked")

         private W createProxy() {

         return (W)Proxy.newProxyInstance(

             SecureLoader.getClassClassLoader(writerType),new Class[]{writerType},this);

     }

     /**

      * Creates a new typed annotation writer.

      */

     @SuppressWarnings("unchecked")

         static <W extends JAnnotationWriter<?>> W create(Class<W> w, JAnnotatable annotatable) {

         Class<? extends Annotation> a = findAnnotationType(w);

         return (W)new TypedAnnotationWriter(a,w,annotatable.annotate(a)).createProxy();

     }

     private static Class<? extends Annotation> findAnnotationType(Class<?> clazz) {

         for( Type t : clazz.getGenericInterfaces()) {

             if(t instanceof ParameterizedType) {

                 ParameterizedType p = (ParameterizedType) t;

                 if(p.getRawType()==JAnnotationWriter.class)

                     return (Class<? extends Annotation>)p.getActualTypeArguments()[0];

             }

             if(t instanceof Class<?>) {

                 // recursive search

                 Class<? extends Annotation> r = findAnnotationType((Class<?>)t);

                 if(r!=null)     return r;

             }

         }

         return null;

     }

 }