/*

    * Copyright (c) 1996, 2006, 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 java.lang.reflect;

  import sun.reflect.FieldAccessor;

  import sun.reflect.Reflection;

  import sun.reflect.generics.repository.FieldRepository;

  import sun.reflect.generics.factory.CoreReflectionFactory;

  import sun.reflect.generics.factory.GenericsFactory;

  import sun.reflect.generics.scope.ClassScope;

  import java.lang.annotation.Annotation;

  import java.util.Map;

  import sun.reflect.annotation.AnnotationParser;

  public final

  class Field extends AccessibleObject implements Member {

      private Class<?>            clazz;

      private int                 slot;

      // This is guaranteed to be interned by the VM in the 1.4

      // reflection implementation

      private String              name;

      private Class<?>            type;

      private int                 modifiers;

      // Generics and annotations support

      private transient String    signature;

      // generic info repository; lazily initialized

      private transient FieldRepository genericInfo;

      private byte[]              annotations;

      // Cached field accessor created without override

      private FieldAccessor fieldAccessor;

      // Cached field accessor created with override

      private FieldAccessor overrideFieldAccessor;

      // For sharing of FieldAccessors. This branching structure is

      // currently only two levels deep (i.e., one root Field and

      // potentially many Field objects pointing to it.)

      private Field               root;

      // Generics infrastructure

      private String getGenericSignature() {return signature;}

      // Accessor for factory

      private GenericsFactory getFactory() {

          Class<?> c = getDeclaringClass();

          // create scope and factory

          return CoreReflectionFactory.make(c, ClassScope.make(c));

      }

      // Accessor for generic info repository

      private FieldRepository getGenericInfo() {

          // lazily initialize repository if necessary

          if (genericInfo == null) {

              // create and cache generic info repository

              genericInfo = FieldRepository.make(getGenericSignature(),

                                                 getFactory());

         }

         return genericInfo; //return cached repository

     }


    

     Field(Class<?> declaringClass,

           String name,

           Class<?> type,

           int modifiers,

           int slot,

           String signature,

           byte[] annotations)

     {

         this.clazz = declaringClass;

         this.name = name;

         this.type = type;

         this.modifiers = modifiers;

         this.slot = slot;

         this.signature = signature;

         this.annotations = annotations;

     }

    

     Field copy() {

         // This routine enables sharing of FieldAccessor objects

         // among Field objects which refer to the same underlying

         // method in the VM. (All of this contortion is only necessary

         // because of the "accessibility" bit in AccessibleObject,

         // which implicitly requires that new java.lang.reflect

         // objects be fabricated for each reflective call on Class

         // objects.)

         Field res = new Field(clazz, name, type, modifiers, slot, signature, annotations);

         res.root = this;

         // Might as well eagerly propagate this if already present

         res.fieldAccessor = fieldAccessor;

         res.overrideFieldAccessor = overrideFieldAccessor;

         return res;

     }

    

     public Class<?> getDeclaringClass() {

         return clazz;

     }

    

     public String getName() {

         return name;

     }

    

     public int getModifiers() {

         return modifiers;

     }

    

     public boolean isEnumConstant() {

         return (getModifiers() & Modifier.ENUM) != 0;

     }

    

     public boolean isSynthetic() {

         return Modifier.isSynthetic(getModifiers());

     }

    

     public Class<?> getType() {

         return type;

     }

    

     public Type getGenericType() {

         if (getGenericSignature() != null)

             return getGenericInfo().getGenericType();

         else

             return getType();

     }


    

     public boolean equals(Object obj) {

         if (obj != null && obj instanceof Field) {

             Field other = (Field)obj;

             return (getDeclaringClass() == other.getDeclaringClass())

                 && (getName() == other.getName())

                 && (getType() == other.getType());

         }

         return false;

     }

    

     public int hashCode() {

         return getDeclaringClass().getName().hashCode() ^ getName().hashCode();

     }

    

     public String toString() {

         int mod = getModifiers();

         return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))

             + getTypeName(getType()) + " "

             + getTypeName(getDeclaringClass()) + "."

             + getName());

     }

    

     public String toGenericString() {

         int mod = getModifiers();

         Type fieldType = getGenericType();

         return (((mod == 0) ? "" : (Modifier.toString(mod) + " "))

             +  ((fieldType instanceof Class) ?

                 getTypeName((Class)fieldType): fieldType.toString())+ " "

             + getTypeName(getDeclaringClass()) + "."

             + getName());

     }

    

     public Object get(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).get(obj);

     }

    

     public boolean getBoolean(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).getBoolean(obj);

     }

    

     public byte getByte(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).getByte(obj);

     }

    

     public char getChar(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).getChar(obj);

     }

    

     public short getShort(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).getShort(obj);

     }

    

     public int getInt(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).getInt(obj);

     }

    

     public long getLong(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).getLong(obj);

     }

    

     public float getFloat(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).getFloat(obj);

     }

    

     public double getDouble(Object obj)

         throws IllegalArgumentException, IllegalAccessException

     {

         return getFieldAccessor(obj).getDouble(obj);

     }

    

     public void set(Object obj, Object value)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).set(obj, value);

     }

    

     public void setBoolean(Object obj, boolean z)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).setBoolean(obj, z);

     }

    

     public void setByte(Object obj, byte b)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).setByte(obj, b);

     }

    

     public void setChar(Object obj, char c)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).setChar(obj, c);

     }

    

     public void setShort(Object obj, short s)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).setShort(obj, s);

     }

    

     public void setInt(Object obj, int i)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).setInt(obj, i);

     }

    

     public void setLong(Object obj, long l)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).setLong(obj, l);

     }

    

     public void setFloat(Object obj, float f)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).setFloat(obj, f);

     }

    

     public void setDouble(Object obj, double d)

         throws IllegalArgumentException, IllegalAccessException

     {

         getFieldAccessor(obj).setDouble(obj, d);

     }

     // Convenience routine which performs security checks

     private FieldAccessor getFieldAccessor(Object obj)

         throws IllegalAccessException

     {

         doSecurityCheck(obj);

         boolean ov = override;

         FieldAccessor a = (ov)? overrideFieldAccessor : fieldAccessor;

         return (a != null)? a : acquireFieldAccessor(ov);

     }

     // NOTE that there is no synchronization used here. It is correct

     // (though not efficient) to generate more than one FieldAccessor

     // for a given Field. However, avoiding synchronization will

     // probably make the implementation more scalable.

     private FieldAccessor acquireFieldAccessor(boolean overrideFinalCheck) {

         // First check to see if one has been created yet, and take it

         // if so

         FieldAccessor tmp = null;

         if (root != null) tmp = root.getFieldAccessor(overrideFinalCheck);

         if (tmp != null) {

             if (overrideFinalCheck)

                 overrideFieldAccessor = tmp;

             else

                 fieldAccessor = tmp;

         } else {

             // Otherwise fabricate one and propagate it up to the root

             tmp = reflectionFactory.newFieldAccessor(this, overrideFinalCheck);

             setFieldAccessor(tmp, overrideFinalCheck);

         }

         return tmp;

     }

     // Returns FieldAccessor for this Field object, not looking up

     // the chain to the root

     private FieldAccessor getFieldAccessor(boolean overrideFinalCheck) {

         return (overrideFinalCheck)? overrideFieldAccessor : fieldAccessor;

     }

     // Sets the FieldAccessor for this Field object and

     // (recursively) its root

     private void setFieldAccessor(FieldAccessor accessor, boolean overrideFinalCheck) {

         if (overrideFinalCheck)

             overrideFieldAccessor = accessor;

         else

             fieldAccessor = accessor;

         // Propagate up

         if (root != null) {

             root.setFieldAccessor(accessor, overrideFinalCheck);

         }

     }

     // NOTE: be very careful if you change the stack depth of this

     // routine. The depth of the "getCallerClass" call is hardwired so

     // that the compiler can have an easier time if this gets inlined.

     private void doSecurityCheck(Object obj) throws IllegalAccessException {

         if (!override) {

             if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {

                 Class<?> caller = Reflection.getCallerClass(4);

                 checkAccess(caller, clazz, obj, modifiers);

             }

         }

     }

     /*

      * Utility routine to paper over array type names

      */

     static String getTypeName(Class<?> type) {

         if (type.isArray()) {

             try {

                 Class<?> cl = type;

                 int dimensions = 0;

                 while (cl.isArray()) {

                     dimensions++;

                     cl = cl.getComponentType();

                 }

                StringBuffer sb = new StringBuffer();

                sb.append(cl.getName());

                for (int i = 0; i < dimensions; i++) {

                    sb.append("[]");

                }

                return sb.toString();

            } catch (Throwable e) { /*FALLTHRU*/ }

        }

        return type.getName();

    }

    

    public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {

        if (annotationClass == null)

            throw new NullPointerException();

        return (T) declaredAnnotations().get(annotationClass);

    }

    

    public Annotation[] getDeclaredAnnotations()  {

        return AnnotationParser.toArray(declaredAnnotations());

    }

    private transient Map<Class<? extends Annotation>, Annotation> declaredAnnotations;

    private synchronized  Map<Class<? extends Annotation>, Annotation> declaredAnnotations() {

        if (declaredAnnotations == null) {

            declaredAnnotations = AnnotationParser.parseAnnotations(

                annotations, sun.misc.SharedSecrets.getJavaLangAccess().

                getConstantPool(getDeclaringClass()),

                getDeclaringClass());

        }

        return declaredAnnotations;

    }

}