/*

   * Copyright 2003-2006 Sun Microsystems, Inc.  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.  Sun designates this

   * particular file as subject to the "Classpath" exception as provided

   * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

  * CA 95054 USA or visit www.sun.com if you need additional information or

  * have any questions.

  */

 package sun.reflect.annotation;

 import java.lang.annotation.*;

 import java.lang.reflect.*;

 import java.util.*;

 import java.security.AccessController;

 import java.security.PrivilegedAction;

 public class AnnotationType {
    

     private final Map<String, Class> memberTypes = new HashMap<String,Class>();

    

     private final Map<String, Object> memberDefaults =

         new HashMap<String, Object>();

    

     private final Map<String, Method> members = new HashMap<String, Method>();

    

     private RetentionPolicy retention = RetentionPolicy.RUNTIME;;

    

     private boolean inherited = false;

    

     public static synchronized AnnotationType getInstance(

         Class annotationClass)

     {

         AnnotationType result = sun.misc.SharedSecrets.getJavaLangAccess().

             getAnnotationType(annotationClass);

         if (result == null)

             result = new AnnotationType((Class<?>) annotationClass);

         return result;

     }

    

     private AnnotationType(final Class<?> annotationClass) {

         if (!annotationClass.isAnnotation())

             throw new IllegalArgumentException("Not an annotation type");

        Method[] methods =

            AccessController.doPrivileged(new PrivilegedAction<Method[]>() {

                public Method[] run() {

                    // Initialize memberTypes and defaultValues

                    return annotationClass.getDeclaredMethods();

                }

            });

        for (Method method :  methods) {

            if (method.getParameterTypes().length != 0)

                throw new IllegalArgumentException(method + " has params");

            String name = method.getName();

            Class type = method.getReturnType();

            memberTypes.put(name, invocationHandlerReturnType(type));

            members.put(name, method);

            Object defaultValue = method.getDefaultValue();

            if (defaultValue != null)

                memberDefaults.put(name, defaultValue);

            members.put(name, method);

        }

        sun.misc.SharedSecrets.getJavaLangAccess().

            setAnnotationType(annotationClass, this);

        // Initialize retention, & inherited fields.  Special treatment

        // of the corresponding annotation types breaks infinite recursion.

        if (annotationClass != Retention.class &&

            annotationClass != Inherited.class) {

            Retention ret = annotationClass.getAnnotation(Retention.class);

            retention = (ret == null ? RetentionPolicy.CLASS : ret.value());

            inherited = annotationClass.isAnnotationPresent(Inherited.class);

        }

    }

    

    public static Class invocationHandlerReturnType(Class type) {

        // Translate primitives to wrappers

        if (type == byte.class)

            return Byte.class;

        if (type == char.class)

            return Character.class;

        if (type == double.class)

            return Double.class;

        if (type == float.class)

            return Float.class;

        if (type == int.class)

            return Integer.class;

        if (type == long.class)

            return Long.class;

        if (type == short.class)

            return Short.class;

        if (type == boolean.class)

            return Boolean.class;

        // Otherwise, just return declared type

        return type;

    }

    

    public Map<String, Class> memberTypes() {

        return memberTypes;

    }

    

    public Map<String, Method> members() {

        return members;

    }

    

    public Map<String, Object> memberDefaults() {

        return memberDefaults;

    }

    

    public RetentionPolicy retention() {

        return retention;

    }

    

    public boolean isInherited() {

        return inherited;

    }

    

    public String toString() {

        StringBuffer s = new StringBuffer("Annotation Type:" + "\n");

        s.append("   Member types: " + memberTypes + "\n");

        s.append("   Member defaults: " + memberDefaults + "\n");

        s.append("   Retention policy: " + retention + "\n");

        s.append("   Inherited: " + inherited);

        return s.toString();

    }

}