1/*
2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package java.lang.reflect;
27
28import jdk.internal.reflect.MethodAccessor;
29import jdk.internal.reflect.ConstructorAccessor;
30
31/** Package-private class implementing the
32    sun.reflect.LangReflectAccess interface, allowing the java.lang
33    package to instantiate objects in this package. */
34
35class ReflectAccess implements jdk.internal.reflect.LangReflectAccess {
36    public Field newField(Class<?> declaringClass,
37                          String name,
38                          Class<?> type,
39                          int modifiers,
40                          int slot,
41                          String signature,
42                          byte[] annotations)
43    {
44        return new Field(declaringClass,
45                         name,
46                         type,
47                         modifiers,
48                         slot,
49                         signature,
50                         annotations);
51    }
52
53    public Method newMethod(Class<?> declaringClass,
54                            String name,
55                            Class<?>[] parameterTypes,
56                            Class<?> returnType,
57                            Class<?>[] checkedExceptions,
58                            int modifiers,
59                            int slot,
60                            String signature,
61                            byte[] annotations,
62                            byte[] parameterAnnotations,
63                            byte[] annotationDefault)
64    {
65        return new Method(declaringClass,
66                          name,
67                          parameterTypes,
68                          returnType,
69                          checkedExceptions,
70                          modifiers,
71                          slot,
72                          signature,
73                          annotations,
74                          parameterAnnotations,
75                          annotationDefault);
76    }
77
78    public <T> Constructor<T> newConstructor(Class<T> declaringClass,
79                                             Class<?>[] parameterTypes,
80                                             Class<?>[] checkedExceptions,
81                                             int modifiers,
82                                             int slot,
83                                             String signature,
84                                             byte[] annotations,
85                                             byte[] parameterAnnotations)
86    {
87        return new Constructor<>(declaringClass,
88                                  parameterTypes,
89                                  checkedExceptions,
90                                  modifiers,
91                                  slot,
92                                  signature,
93                                  annotations,
94                                  parameterAnnotations);
95    }
96
97    public MethodAccessor getMethodAccessor(Method m) {
98        return m.getMethodAccessor();
99    }
100
101    public void setMethodAccessor(Method m, MethodAccessor accessor) {
102        m.setMethodAccessor(accessor);
103    }
104
105    public ConstructorAccessor getConstructorAccessor(Constructor<?> c) {
106        return c.getConstructorAccessor();
107    }
108
109    public void setConstructorAccessor(Constructor<?> c,
110                                       ConstructorAccessor accessor)
111    {
112        c.setConstructorAccessor(accessor);
113    }
114
115    public int getConstructorSlot(Constructor<?> c) {
116        return c.getSlot();
117    }
118
119    public String getConstructorSignature(Constructor<?> c) {
120        return c.getSignature();
121    }
122
123    public byte[] getConstructorAnnotations(Constructor<?> c) {
124        return c.getRawAnnotations();
125    }
126
127    public byte[] getConstructorParameterAnnotations(Constructor<?> c) {
128        return c.getRawParameterAnnotations();
129    }
130
131    public byte[] getExecutableTypeAnnotationBytes(Executable ex) {
132        return ex.getTypeAnnotationBytes();
133    }
134
135    public Class<?>[] getExecutableSharedParameterTypes(Executable ex) {
136        return ex.getSharedParameterTypes();
137    }
138
139    //
140    // Copying routines, needed to quickly fabricate new Field,
141    // Method, and Constructor objects from templates
142    //
143    public Method      copyMethod(Method arg) {
144        return arg.copy();
145    }
146    public Method      leafCopyMethod(Method arg) {
147        return arg.leafCopy();
148    }
149
150    public Field       copyField(Field arg) {
151        return arg.copy();
152    }
153
154    public <T> Constructor<T> copyConstructor(Constructor<T> arg) {
155        return arg.copy();
156    }
157}
158