jdk/src/java.base/share/classes/sun/reflect/annotation/AnnotationInvocationHandler.java
author igerasim
Wed, 02 Nov 2016 20:53:56 +0300
changeset 41882 0549e50db4bf
parent 40116 9bde91c0d0ef
child 46873 7ac2f551b0d6
permissions -rw-r--r--
8168921: Inconsistent Annotation.toString() Reviewed-by: darcy, redestad
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
38770
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
     2
 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 3959
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 3959
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
5506
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 3959
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 3959
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
202f599c92aa 6943119: Rebrand source copyright notices
ohair
parents: 3959
diff changeset
    23
 * questions.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package sun.reflect.annotation;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
    28
import java.io.ObjectInputStream;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import java.lang.annotation.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
import java.lang.reflect.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.io.Serializable;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
import java.util.*;
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
    33
import java.util.stream.*;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
import java.security.AccessController;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
import java.security.PrivilegedAction;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
 * InvocationHandler for dynamic proxy implementation of Annotation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
 * @author  Josh Bloch
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 * @since   1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
class AnnotationInvocationHandler implements InvocationHandler, Serializable {
10357
c2cde4cd24a1 7080038: (ann) Serializable types in sun.reflect.annotation do not declare serialVersionUIDs
darcy
parents: 5506
diff changeset
    44
    private static final long serialVersionUID = 6182022883658399397L;
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
    45
    private final Class<? extends Annotation> type;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
    private final Map<String, Object> memberValues;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
    48
    AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
27069
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    49
        Class<?>[] superInterfaces = type.getInterfaces();
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    50
        if (!type.isAnnotation() ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    51
            superInterfaces.length != 1 ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    52
            superInterfaces[0] != java.lang.annotation.Annotation.class)
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    53
            throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
        this.type = type;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
        this.memberValues = memberValues;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
    public Object invoke(Object proxy, Method method, Object[] args) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
        String member = method.getName();
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
    60
        Class<?>[] paramTypes = method.getParameterTypes();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
        // Handle Object and Annotation methods
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
        if (member.equals("equals") && paramTypes.length == 1 &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
            paramTypes[0] == Object.class)
39043
815e52744068 8071859: AnnotationInvocationHandler.equals(Object) return true when apply to annotation
darcy
parents: 38770
diff changeset
    65
            return equalsImpl(proxy, args[0]);
27069
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    66
        if (paramTypes.length != 0)
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    67
            throw new AssertionError("Too many parameters for an annotation method");
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    68
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    69
        switch(member) {
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    70
        case "toString":
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
            return toStringImpl();
27069
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    72
        case "hashCode":
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
            return hashCodeImpl();
27069
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    74
        case "annotationType":
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
            return type;
27069
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
    76
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
        // Handle annotation member accessors
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
        Object result = memberValues.get(member);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
        if (result == null)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
            throw new IncompleteAnnotationException(type, member);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
        if (result instanceof ExceptionProxy)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
            throw ((ExceptionProxy) result).generateException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
        if (result.getClass().isArray() && Array.getLength(result) != 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
            result = cloneArray(result);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
     * This method, which clones its array argument, would not be necessary
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
     * if Cloneable had a public clone method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
    private Object cloneArray(Object array) {
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
    98
        Class<?> type = array.getClass();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
        if (type == byte[].class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
            byte[] byteArray = (byte[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
            return byteArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
        if (type == char[].class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
            char[] charArray = (char[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
            return charArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
        if (type == double[].class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
            double[] doubleArray = (double[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
            return doubleArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
        if (type == float[].class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
            float[] floatArray = (float[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
            return floatArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
        if (type == int[].class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
            int[] intArray = (int[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
            return intArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
        if (type == long[].class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
            long[] longArray = (long[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
            return longArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
        if (type == short[].class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
            short[] shortArray = (short[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
            return shortArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
        if (type == boolean[].class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
            boolean[] booleanArray = (boolean[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
            return booleanArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
        Object[] objectArray = (Object[])array;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
        return objectArray.clone();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
     * Implementation of dynamicProxy.toString()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
    private String toStringImpl() {
27069
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   142
        StringBuilder result = new StringBuilder(128);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
        result.append('@');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
        result.append(type.getName());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
        result.append('(');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
        boolean firstMember = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
        for (Map.Entry<String, Object> e : memberValues.entrySet()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
            if (firstMember)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
                firstMember = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
            else
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
                result.append(", ");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
            result.append(e.getKey());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
            result.append('=');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
            result.append(memberValueToString(e.getValue()));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
        result.append(')');
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
        return result.toString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
    /**
38770
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   162
     * Translates a member value (in "dynamic proxy return form") into a string.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
    private static String memberValueToString(Object value) {
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
   165
        Class<?> type = value.getClass();
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   166
        if (!type.isArray()) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   167
            // primitive value, string, class, enum const, or annotation
38770
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   168
            if (type == Class.class)
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   169
                return toSourceString((Class<?>) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   170
            else if (type == String.class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   171
                return  toSourceString((String) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   172
            if (type == Character.class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   173
                return toSourceString((char) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   174
            else if (type == Double.class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   175
                return  toSourceString((double) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   176
            else if (type == Float.class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   177
                return  toSourceString((float) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   178
            else if (type == Long.class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   179
                return  toSourceString((long) value);
38770
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   180
            else
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   181
                return value.toString();
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   182
        } else {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   183
            Stream<String> stringStream;
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   184
            if (type == byte[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   185
                stringStream = convert((byte[]) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   186
            else if (type == char[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   187
                stringStream = convert((char[]) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   188
            else if (type == double[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   189
                stringStream = DoubleStream.of((double[]) value)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   190
                    .mapToObj(AnnotationInvocationHandler::toSourceString);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   191
            else if (type == float[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   192
                stringStream = convert((float[]) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   193
            else if (type == int[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   194
                stringStream = IntStream.of((int[]) value).mapToObj(String::valueOf);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   195
            else if (type == long[].class) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   196
                stringStream = LongStream.of((long[]) value)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   197
                    .mapToObj(AnnotationInvocationHandler::toSourceString);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   198
            } else if (type == short[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   199
                stringStream = convert((short[]) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   200
            else if (type == boolean[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   201
                stringStream = convert((boolean[]) value);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   202
            else if (type == Class[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   203
                stringStream =
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   204
                    Arrays.stream((Class<?>[]) value).
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   205
                    map(AnnotationInvocationHandler::toSourceString);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   206
            else if (type == String[].class)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   207
                stringStream =
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   208
                    Arrays.stream((String[])value).
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   209
                    map(AnnotationInvocationHandler::toSourceString);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   210
            else
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   211
                stringStream = Arrays.stream((Object[])value).map(Objects::toString);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   213
            return stringStreamToString(stringStream);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   214
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
    /**
38770
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   218
     * Translates a Class value to a form suitable for use in the
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   219
     * string representation of an annotation.
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   220
     */
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   221
    private static String toSourceString(Class<?> clazz) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   222
        Class<?> finalComponent = clazz;
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   223
        StringBuilder arrayBackets = new StringBuilder();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   224
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   225
        while(finalComponent.isArray()) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   226
            finalComponent = finalComponent.getComponentType();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   227
            arrayBackets.append("[]");
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   228
        }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   229
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   230
        return finalComponent.getName() + arrayBackets.toString() + ".class" ;
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   231
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   232
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   233
    private static String toSourceString(float f) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   234
        if (Float.isFinite(f))
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   235
            return Float.toString(f) + "f" ;
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   236
        else {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   237
            if (Float.isInfinite(f)) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   238
                return (f < 0.0f) ? "-1.0f/0.0f": "1.0f/0.0f";
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   239
            } else
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   240
                return "0.0f/0.0f";
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   241
        }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   242
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   243
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   244
    private static String toSourceString(double d) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   245
        if (Double.isFinite(d))
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   246
            return Double.toString(d);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   247
        else {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   248
            if (Double.isInfinite(d)) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   249
                return (d < 0.0f) ? "-1.0/0.0": "1.0/0.0";
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   250
            } else
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   251
                return "0.0/0.0";
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   252
        }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   253
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   254
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   255
    private static String toSourceString(char c) {
41882
0549e50db4bf 8168921: Inconsistent Annotation.toString()
igerasim
parents: 40116
diff changeset
   256
        StringBuilder sb = new StringBuilder(4);
0549e50db4bf 8168921: Inconsistent Annotation.toString()
igerasim
parents: 40116
diff changeset
   257
        sb.append('\'');
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   258
        if (c == '\'')
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   259
            sb.append("\\'");
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   260
        else
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   261
            sb.append(c);
41882
0549e50db4bf 8168921: Inconsistent Annotation.toString()
igerasim
parents: 40116
diff changeset
   262
        return sb.append('\'')
0549e50db4bf 8168921: Inconsistent Annotation.toString()
igerasim
parents: 40116
diff changeset
   263
                .toString();
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   264
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   265
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   266
    private static String toSourceString(long ell) {
41882
0549e50db4bf 8168921: Inconsistent Annotation.toString()
igerasim
parents: 40116
diff changeset
   267
        String str = String.valueOf(ell);
0549e50db4bf 8168921: Inconsistent Annotation.toString()
igerasim
parents: 40116
diff changeset
   268
        return (ell < Integer.MIN_VALUE || ell > Integer.MAX_VALUE)
0549e50db4bf 8168921: Inconsistent Annotation.toString()
igerasim
parents: 40116
diff changeset
   269
                ? (str + 'L') : str;
38770
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   270
    }
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   271
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   272
    /**
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   273
     * Return a string suitable for use in the string representation
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   274
     * of an annotation.
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   275
     */
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   276
    private static String toSourceString(String s) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   277
        StringBuilder sb = new StringBuilder();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   278
        sb.append('"');
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   279
        // Escape embedded quote characters, if present, but don't do
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   280
        // anything more heroic.
41882
0549e50db4bf 8168921: Inconsistent Annotation.toString()
igerasim
parents: 40116
diff changeset
   281
        sb.append(s.replace("\"", "\\\""));
40116
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   282
        sb.append('"');
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   283
        return sb.toString();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   284
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   285
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   286
    private static Stream<String> convert(byte[] values) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   287
        List<String> list = new ArrayList<>(values.length);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   288
        for (byte b : values)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   289
            list.add(Byte.toString(b));
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   290
        return list.stream();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   291
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   292
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   293
    private static Stream<String> convert(char[] values) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   294
        List<String> list = new ArrayList<>(values.length);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   295
        for (char c : values)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   296
            list.add(toSourceString(c));
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   297
        return list.stream();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   298
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   299
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   300
    private static Stream<String> convert(float[] values) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   301
        List<String> list = new ArrayList<>(values.length);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   302
        for (float f : values) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   303
            list.add(toSourceString(f));
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   304
        }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   305
        return list.stream();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   306
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   307
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   308
    private static Stream<String> convert(short[] values) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   309
        List<String> list = new ArrayList<>(values.length);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   310
        for (short s : values)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   311
            list.add(Short.toString(s));
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   312
        return list.stream();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   313
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   314
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   315
    private static Stream<String> convert(boolean[] values) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   316
        List<String> list = new ArrayList<>(values.length);
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   317
        for (boolean b : values)
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   318
            list.add(Boolean.toString(b));
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   319
        return list.stream();
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   320
    }
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   321
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   322
    private static String stringStreamToString(Stream<String> stream) {
9bde91c0d0ef 8162817: Annotation toString output not reusable for source input
darcy
parents: 39043
diff changeset
   323
        return stream.collect(Collectors.joining(", ", "{", "}"));
38770
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   324
    }
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   325
e8746fa36f1a 5040830: (ann) please improve toString() for annotations containing exception proxies
darcy
parents: 35295
diff changeset
   326
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
     * Implementation of dynamicProxy.equals(Object o)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
     */
39043
815e52744068 8071859: AnnotationInvocationHandler.equals(Object) return true when apply to annotation
darcy
parents: 38770
diff changeset
   329
    private Boolean equalsImpl(Object proxy, Object o) {
815e52744068 8071859: AnnotationInvocationHandler.equals(Object) return true when apply to annotation
darcy
parents: 38770
diff changeset
   330
        if (o == proxy)
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
        if (!type.isInstance(o))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
        for (Method memberMethod : getMemberMethods()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
            String member = memberMethod.getName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
            Object ourValue = memberValues.get(member);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
            Object hisValue = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
            AnnotationInvocationHandler hisHandler = asOneOfUs(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
            if (hisHandler != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
                hisValue = hisHandler.memberValues.get(member);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
                try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
                    hisValue = memberMethod.invoke(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
                } catch (InvocationTargetException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
                } catch (IllegalAccessException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
                    throw new AssertionError(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
            if (!memberValueEquals(ourValue, hisValue))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
     * Returns an object's invocation handler if that object is a dynamic
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
     * proxy with a handler of type AnnotationInvocationHandler.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
     * Returns null otherwise.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
    private AnnotationInvocationHandler asOneOfUs(Object o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
        if (Proxy.isProxyClass(o.getClass())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
            InvocationHandler handler = Proxy.getInvocationHandler(o);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
            if (handler instanceof AnnotationInvocationHandler)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
                return (AnnotationInvocationHandler) handler;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
     * Returns true iff the two member values in "dynamic proxy return form"
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
     * are equal using the appropriate equality function depending on the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
     * member type.  The two values will be of the same type unless one of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
     * the containing annotations is ill-formed.  If one of the containing
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
     * annotations is ill-formed, this method will return false unless the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
     * two members are identical object references.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
    private static boolean memberValueEquals(Object v1, Object v2) {
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
   380
        Class<?> type = v1.getClass();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
        // Check for primitive, string, class, enum const, annotation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
        // or ExceptionProxy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
        if (!type.isArray())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
            return v1.equals(v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
        // Check for array of string, class, enum const, annotation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
        // or ExceptionProxy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
        if (v1 instanceof Object[] && v2 instanceof Object[])
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
            return Arrays.equals((Object[]) v1, (Object[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
        // Check for ill formed annotation(s)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
        if (v2.getClass() != type)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
        // Deal with array of primitives
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
        if (type == byte[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
            return Arrays.equals((byte[]) v1, (byte[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
        if (type == char[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
            return Arrays.equals((char[]) v1, (char[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
        if (type == double[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
            return Arrays.equals((double[]) v1, (double[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
        if (type == float[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
            return Arrays.equals((float[]) v1, (float[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
        if (type == int[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
            return Arrays.equals((int[]) v1, (int[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
        if (type == long[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
            return Arrays.equals((long[]) v1, (long[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
        if (type == short[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
            return Arrays.equals((short[]) v1, (short[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
        assert type == boolean[].class;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
        return Arrays.equals((boolean[]) v1, (boolean[]) v2);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
     * Returns the member methods for our annotation type.  These are
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
     * obtained lazily and cached, as they're expensive to obtain
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
     * and we only need them if our equals method is invoked (which should
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
     * be rare).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
    private Method[] getMemberMethods() {
28056
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   422
        Method[] value = memberMethods;
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   423
        if (value == null) {
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   424
            value = computeMemberMethods();
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   425
            memberMethods = value;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
        }
28056
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   427
        return value;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
    }
28056
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   429
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   430
    private Method[] computeMemberMethods() {
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   431
        return AccessController.doPrivileged(
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   432
            new PrivilegedAction<Method[]>() {
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   433
                public Method[] run() {
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   434
                    final Method[] methods = type.getDeclaredMethods();
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   435
                    validateAnnotationMethods(methods);
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   436
                    AccessibleObject.setAccessible(methods, true);
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   437
                    return methods;
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   438
                }});
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   439
    }
0cab6eb92852 8065172: More core reflection final and volatile annotations
martin
parents: 27069
diff changeset
   440
34774
03b4e6dc367b 8145680: Remove unnecessary explicit initialization of volatile variables in java.base
redestad
parents: 28056
diff changeset
   441
    private transient volatile Method[] memberMethods;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
    /**
27069
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   444
     * Validates that a method is structurally appropriate for an
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   445
     * annotation type. As of Java SE 8, annotation types cannot
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   446
     * contain static methods and the declared methods of an
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   447
     * annotation type must take zero arguments and there are
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   448
     * restrictions on the return type.
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   449
     */
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   450
    private void validateAnnotationMethods(Method[] memberMethods) {
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   451
        /*
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   452
         * Specification citations below are from JLS
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   453
         * 9.6.1. Annotation Type Elements
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   454
         */
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   455
        boolean valid = true;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   456
        for(Method method : memberMethods) {
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   457
            /*
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   458
             * "By virtue of the AnnotationTypeElementDeclaration
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   459
             * production, a method declaration in an annotation type
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   460
             * declaration cannot have formal parameters, type
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   461
             * parameters, or a throws clause.
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   462
             *
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   463
             * "By virtue of the AnnotationTypeElementModifier
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   464
             * production, a method declaration in an annotation type
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   465
             * declaration cannot be default or static."
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   466
             */
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   467
            if (method.getModifiers() != (Modifier.PUBLIC | Modifier.ABSTRACT) ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   468
                method.isDefault() ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   469
                method.getParameterCount() != 0 ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   470
                method.getExceptionTypes().length != 0) {
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   471
                valid = false;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   472
                break;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   473
            }
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   474
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   475
            /*
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   476
             * "It is a compile-time error if the return type of a
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   477
             * method declared in an annotation type is not one of the
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   478
             * following: a primitive type, String, Class, any
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   479
             * parameterized invocation of Class, an enum type
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   480
             * (section 8.9), an annotation type, or an array type
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   481
             * (chapter 10) whose element type is one of the preceding
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   482
             * types."
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   483
             */
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   484
            Class<?> returnType = method.getReturnType();
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   485
            if (returnType.isArray()) {
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   486
                returnType = returnType.getComponentType();
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   487
                if (returnType.isArray()) { // Only single dimensional arrays
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   488
                    valid = false;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   489
                    break;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   490
                }
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   491
            }
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   492
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   493
            if (!((returnType.isPrimitive() && returnType != void.class) ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   494
                  returnType == java.lang.String.class ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   495
                  returnType == java.lang.Class.class ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   496
                  returnType.isEnum() ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   497
                  returnType.isAnnotation())) {
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   498
                valid = false;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   499
                break;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   500
            }
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   501
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   502
            /*
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   503
             * "It is a compile-time error if any method declared in an
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   504
             * annotation type has a signature that is
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   505
             * override-equivalent to that of any public or protected
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   506
             * method declared in class Object or in the interface
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   507
             * java.lang.annotation.Annotation."
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   508
             *
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   509
             * The methods in Object or Annotation meeting the other
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   510
             * criteria (no arguments, contrained return type, etc.)
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   511
             * above are:
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   512
             *
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   513
             * String toString()
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   514
             * int hashCode()
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   515
             * Class<? extends Annotation> annotationType()
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   516
             */
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   517
            String methodName = method.getName();
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   518
            if ((methodName.equals("toString") && returnType == java.lang.String.class) ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   519
                (methodName.equals("hashCode") && returnType == int.class) ||
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   520
                (methodName.equals("annotationType") && returnType == java.lang.Class.class)) {
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   521
                valid = false;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   522
                break;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   523
            }
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   524
        }
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   525
        if (valid)
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   526
            return;
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   527
        else
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   528
            throw new AnnotationFormatError("Malformed method on an annotation type");
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   529
    }
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   530
ee10bb4f6dc4 8035781: Improve equality for annotations
darcy
parents: 25859
diff changeset
   531
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
     * Implementation of dynamicProxy.hashCode()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
    private int hashCodeImpl() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
        int result = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
        for (Map.Entry<String, Object> e : memberValues.entrySet()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
            result += (127 * e.getKey().hashCode()) ^
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
                memberValueHashCode(e.getValue());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
        return result;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
     * Computes hashCode of a member value (in "dynamic proxy return form")
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
    private static int memberValueHashCode(Object value) {
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
   547
        Class<?> type = value.getClass();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
        if (!type.isArray())    // primitive, string, class, enum const,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
                                // or annotation
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
            return value.hashCode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
        if (type == byte[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
            return Arrays.hashCode((byte[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
        if (type == char[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
            return Arrays.hashCode((char[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
        if (type == double[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
            return Arrays.hashCode((double[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
        if (type == float[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
            return Arrays.hashCode((float[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
        if (type == int[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
            return Arrays.hashCode((int[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
        if (type == long[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
            return Arrays.hashCode((long[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
        if (type == short[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
            return Arrays.hashCode((short[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
        if (type == boolean[].class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
            return Arrays.hashCode((boolean[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
        return Arrays.hashCode((Object[]) value);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
    private void readObject(java.io.ObjectInputStream s)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
        throws java.io.IOException, ClassNotFoundException {
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   573
        ObjectInputStream.GetField fields = s.readFields();
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   574
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   575
        @SuppressWarnings("unchecked")
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   576
        Class<? extends Annotation> t = (Class<? extends Annotation>)fields.get("type", null);
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   577
        @SuppressWarnings("unchecked")
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   578
        Map<String, Object> streamVals = (Map<String, Object>)fields.get("memberValues", null);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
        // Check to make sure that types have not evolved incompatibly
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
        AnnotationType annotationType = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
        try {
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   584
            annotationType = AnnotationType.getInstance(t);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
        } catch(IllegalArgumentException e) {
18199
bfd86c4f4249 8001309: Better handling of annotation interfaces
darcy
parents: 10357
diff changeset
   586
            // Class is no longer an annotation type; time to punch out
bfd86c4f4249 8001309: Better handling of annotation interfaces
darcy
parents: 10357
diff changeset
   587
            throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
   590
        Map<String, Class<?>> memberTypes = annotationType.memberTypes();
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   591
        // consistent with runtime Map type
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   592
        Map<String, Object> mv = new LinkedHashMap<>();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
18199
bfd86c4f4249 8001309: Better handling of annotation interfaces
darcy
parents: 10357
diff changeset
   594
        // If there are annotation members without values, that
bfd86c4f4249 8001309: Better handling of annotation interfaces
darcy
parents: 10357
diff changeset
   595
        // situation is handled by the invoke method.
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   596
        for (Map.Entry<String, Object> memberValue : streamVals.entrySet()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
            String name = memberValue.getKey();
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   598
            Object value = null;
3959
05a07c0a273b 5062288: (reflect) Core reflection uses raw types when it could be using wildcards
darcy
parents: 1508
diff changeset
   599
            Class<?> memberType = memberTypes.get(name);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
            if (memberType != null) {  // i.e. member still exists
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   601
                value = memberValue.getValue();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
                if (!(memberType.isInstance(value) ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
                      value instanceof ExceptionProxy)) {
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   604
                    value = new AnnotationTypeMismatchExceptionProxy(
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
                            value.getClass() + "[" + value + "]").setMember(
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   606
                                annotationType.members().get(name));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
            }
35295
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   609
            mv.put(name, value);
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   610
        }
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   611
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   612
        UnsafeAccessor.setType(this, t);
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   613
        UnsafeAccessor.setMemberValues(this, mv);
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   614
    }
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   615
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   616
    private static class UnsafeAccessor {
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   617
        private static final jdk.internal.misc.Unsafe unsafe;
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   618
        private static final long typeOffset;
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   619
        private static final long memberValuesOffset;
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   620
        static {
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   621
            try {
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   622
                unsafe = jdk.internal.misc.Unsafe.getUnsafe();
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   623
                typeOffset = unsafe.objectFieldOffset
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   624
                        (AnnotationInvocationHandler.class.getDeclaredField("type"));
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   625
                memberValuesOffset = unsafe.objectFieldOffset
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   626
                        (AnnotationInvocationHandler.class.getDeclaredField("memberValues"));
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   627
            } catch (Exception ex) {
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   628
                throw new ExceptionInInitializerError(ex);
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   629
            }
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   630
        }
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   631
        static void setType(AnnotationInvocationHandler o,
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   632
                            Class<? extends Annotation> type) {
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   633
            unsafe.putObject(o, typeOffset, type);
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   634
        }
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   635
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   636
        static void setMemberValues(AnnotationInvocationHandler o,
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   637
                                    Map<String, Object> memberValues) {
80c40839a17e 8143185: Cleanup for handling proxies
chegar
parents: 34774
diff changeset
   638
            unsafe.putObject(o, memberValuesOffset, memberValues);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   639
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   640
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   641
}