1 /*
   2  * Copyright (c) 2001, 2019, 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 
  26 package java.lang.reflect;
  27 
  28 import jdk.internal.reflect.MethodAccessor;
  29 import jdk.internal.reflect.ConstructorAccessor;
  30 
  31 /** Package-private class implementing the
  32     jdk.internal.access.JavaLangReflectAccess interface, allowing the java.lang
  33     package to instantiate objects in this package. */
  34 
  35 class ReflectAccess implements jdk.internal.access.JavaLangReflectAccess {
  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     @SuppressWarnings("unchecked")
 159     public <T extends AccessibleObject> T getRoot(T obj) {
 160         return (T) obj.getRoot();
 161     }
 162 
 163     public <T> T newInstance(Constructor<T> ctor, Object[] args, Class<?> caller)
 164         throws IllegalAccessException, InstantiationException, InvocationTargetException
 165     {
 166         return ctor.newInstanceWithCaller(args, true, caller);
 167     }
 168 }
--- EOF ---