1 /*
   2  * Copyright 2001-2004 Sun Microsystems, Inc.  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.  Sun designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  22  * CA 95054 USA or visit www.sun.com if you need additional information or
  23  * have any questions.
  24  */
  25 
  26 package java.lang.reflect;
  27 
  28 import sun.reflect.MethodAccessor;
  29 import sun.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 
  35 class ReflectAccess implements sun.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<T>(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     //
 132     // Copying routines, needed to quickly fabricate new Field,
 133     // Method, and Constructor objects from templates
 134     //
 135     public Method      copyMethod(Method arg) {
 136         return arg.copy();
 137     }
 138 
 139     public Field       copyField(Field arg) {
 140         return arg.copy();
 141     }
 142 
 143     public <T> Constructor<T> copyConstructor(Constructor<T> arg) {
 144         return arg.copy();
 145     }
 146 }