Save This Page
Home » openjdk-7 » java » lang » reflect » [javadoc | source]
    1   /*
    2    * Copyright (c) 2001, 2010, 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 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<>(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   }

Save This Page
Home » openjdk-7 » java » lang » reflect » [javadoc | source]