Save This Page
Home » openjdk-7 » java » lang » reflect » [javadoc | source]
    1   /*
    2    * Copyright (c) 1996, 2008, 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 java.security.AccessController;
   29   import sun.reflect.LangReflectAccess;
   30   import sun.reflect.ReflectionFactory;
   31   
   32   /**
   33    * The Modifier class provides {@code static} methods and
   34    * constants to decode class and member access modifiers.  The sets of
   35    * modifiers are represented as integers with distinct bit positions
   36    * representing different modifiers.  The values for the constants
   37    * representing the modifiers are taken from the tables in sections 4.1, 4.4, 4.5, and 4.7 of
   38    * <cite>The Java&trade; Virtual Machine Specification</cite>.
   39    *
   40    * @see Class#getModifiers()
   41    * @see Member#getModifiers()
   42    *
   43    * @author Nakul Saraiya
   44    * @author Kenneth Russell
   45    */
   46   public
   47   class Modifier {
   48   
   49       /*
   50        * Bootstrapping protocol between java.lang and java.lang.reflect
   51        *  packages
   52        */
   53       static {
   54           sun.reflect.ReflectionFactory factory =
   55               AccessController.doPrivileged(
   56                   new ReflectionFactory.GetReflectionFactoryAction());
   57           factory.setLangReflectAccess(new java.lang.reflect.ReflectAccess());
   58       }
   59   
   60       /**
   61        * Return {@code true} if the integer argument includes the
   62        * {@code public} modifier, {@code false} otherwise.
   63        *
   64        * @param   mod a set of modifiers
   65        * @return {@code true} if {@code mod} includes the
   66        * {@code public} modifier; {@code false} otherwise.
   67        */
   68       public static boolean isPublic(int mod) {
   69           return (mod & PUBLIC) != 0;
   70       }
   71   
   72       /**
   73        * Return {@code true} if the integer argument includes the
   74        * {@code private} modifier, {@code false} otherwise.
   75        *
   76        * @param   mod a set of modifiers
   77        * @return {@code true} if {@code mod} includes the
   78        * {@code private} modifier; {@code false} otherwise.
   79        */
   80       public static boolean isPrivate(int mod) {
   81           return (mod & PRIVATE) != 0;
   82       }
   83   
   84       /**
   85        * Return {@code true} if the integer argument includes the
   86        * {@code protected} modifier, {@code false} otherwise.
   87        *
   88        * @param   mod a set of modifiers
   89        * @return {@code true} if {@code mod} includes the
   90        * {@code protected} modifier; {@code false} otherwise.
   91        */
   92       public static boolean isProtected(int mod) {
   93           return (mod & PROTECTED) != 0;
   94       }
   95   
   96       /**
   97        * Return {@code true} if the integer argument includes the
   98        * {@code static} modifier, {@code false} otherwise.
   99        *
  100        * @param   mod a set of modifiers
  101        * @return {@code true} if {@code mod} includes the
  102        * {@code static} modifier; {@code false} otherwise.
  103        */
  104       public static boolean isStatic(int mod) {
  105           return (mod & STATIC) != 0;
  106       }
  107   
  108       /**
  109        * Return {@code true} if the integer argument includes the
  110        * {@code final} modifier, {@code false} otherwise.
  111        *
  112        * @param   mod a set of modifiers
  113        * @return {@code true} if {@code mod} includes the
  114        * {@code final} modifier; {@code false} otherwise.
  115        */
  116       public static boolean isFinal(int mod) {
  117           return (mod & FINAL) != 0;
  118       }
  119   
  120       /**
  121        * Return {@code true} if the integer argument includes the
  122        * {@code synchronized} modifier, {@code false} otherwise.
  123        *
  124        * @param   mod a set of modifiers
  125        * @return {@code true} if {@code mod} includes the
  126        * {@code synchronized} modifier; {@code false} otherwise.
  127        */
  128       public static boolean isSynchronized(int mod) {
  129           return (mod & SYNCHRONIZED) != 0;
  130       }
  131   
  132       /**
  133        * Return {@code true} if the integer argument includes the
  134        * {@code volatile} modifier, {@code false} otherwise.
  135        *
  136        * @param   mod a set of modifiers
  137        * @return {@code true} if {@code mod} includes the
  138        * {@code volatile} modifier; {@code false} otherwise.
  139        */
  140       public static boolean isVolatile(int mod) {
  141           return (mod & VOLATILE) != 0;
  142       }
  143   
  144       /**
  145        * Return {@code true} if the integer argument includes the
  146        * {@code transient} modifier, {@code false} otherwise.
  147        *
  148        * @param   mod a set of modifiers
  149        * @return {@code true} if {@code mod} includes the
  150        * {@code transient} modifier; {@code false} otherwise.
  151        */
  152       public static boolean isTransient(int mod) {
  153           return (mod & TRANSIENT) != 0;
  154       }
  155   
  156       /**
  157        * Return {@code true} if the integer argument includes the
  158        * {@code native} modifier, {@code false} otherwise.
  159        *
  160        * @param   mod a set of modifiers
  161        * @return {@code true} if {@code mod} includes the
  162        * {@code native} modifier; {@code false} otherwise.
  163        */
  164       public static boolean isNative(int mod) {
  165           return (mod & NATIVE) != 0;
  166       }
  167   
  168       /**
  169        * Return {@code true} if the integer argument includes the
  170        * {@code interface} modifier, {@code false} otherwise.
  171        *
  172        * @param   mod a set of modifiers
  173        * @return {@code true} if {@code mod} includes the
  174        * {@code interface} modifier; {@code false} otherwise.
  175        */
  176       public static boolean isInterface(int mod) {
  177           return (mod & INTERFACE) != 0;
  178       }
  179   
  180       /**
  181        * Return {@code true} if the integer argument includes the
  182        * {@code abstract} modifier, {@code false} otherwise.
  183        *
  184        * @param   mod a set of modifiers
  185        * @return {@code true} if {@code mod} includes the
  186        * {@code abstract} modifier; {@code false} otherwise.
  187        */
  188       public static boolean isAbstract(int mod) {
  189           return (mod & ABSTRACT) != 0;
  190       }
  191   
  192       /**
  193        * Return {@code true} if the integer argument includes the
  194        * {@code strictfp} modifier, {@code false} otherwise.
  195        *
  196        * @param   mod a set of modifiers
  197        * @return {@code true} if {@code mod} includes the
  198        * {@code strictfp} modifier; {@code false} otherwise.
  199        */
  200       public static boolean isStrict(int mod) {
  201           return (mod & STRICT) != 0;
  202       }
  203   
  204       /**
  205        * Return a string describing the access modifier flags in
  206        * the specified modifier. For example:
  207        * <blockquote><pre>
  208        *    public final synchronized strictfp
  209        * </pre></blockquote>
  210        * The modifier names are returned in an order consistent with the
  211        * suggested modifier orderings given in sections 8.1.1, 8.3.1, 8.4.3, 8.8.3, and 9.1.1 of
  212        * <cite>The Java&trade; Language Specification</cite>.
  213        * The full modifier ordering used by this method is:
  214        * <blockquote> {@code
  215        * public protected private abstract static final transient
  216        * volatile synchronized native strictfp
  217        * interface } </blockquote>
  218        * The {@code interface} modifier discussed in this class is
  219        * not a true modifier in the Java language and it appears after
  220        * all other modifiers listed by this method.  This method may
  221        * return a string of modifiers that are not valid modifiers of a
  222        * Java entity; in other words, no checking is done on the
  223        * possible validity of the combination of modifiers represented
  224        * by the input.
  225        *
  226        * Note that to perform such checking for a known kind of entity,
  227        * such as a constructor or method, first AND the argument of
  228        * {@code toString} with the appropriate mask from a method like
  229        * {@link #constructorModifiers} or {@link #methodModifiers}.
  230        *
  231        * @param   mod a set of modifiers
  232        * @return  a string representation of the set of modifiers
  233        * represented by {@code mod}
  234        */
  235       public static String toString(int mod) {
  236           StringBuffer sb = new StringBuffer();
  237           int len;
  238   
  239           if ((mod & PUBLIC) != 0)        sb.append("public ");
  240           if ((mod & PROTECTED) != 0)     sb.append("protected ");
  241           if ((mod & PRIVATE) != 0)       sb.append("private ");
  242   
  243           /* Canonical order */
  244           if ((mod & ABSTRACT) != 0)      sb.append("abstract ");
  245           if ((mod & STATIC) != 0)        sb.append("static ");
  246           if ((mod & FINAL) != 0)         sb.append("final ");
  247           if ((mod & TRANSIENT) != 0)     sb.append("transient ");
  248           if ((mod & VOLATILE) != 0)      sb.append("volatile ");
  249           if ((mod & SYNCHRONIZED) != 0)  sb.append("synchronized ");
  250           if ((mod & NATIVE) != 0)        sb.append("native ");
  251           if ((mod & STRICT) != 0)        sb.append("strictfp ");
  252           if ((mod & INTERFACE) != 0)     sb.append("interface ");
  253   
  254           if ((len = sb.length()) > 0)    /* trim trailing space */
  255               return sb.toString().substring(0, len-1);
  256           return "";
  257       }
  258   
  259       /*
  260        * Access modifier flag constants from tables 4.1, 4.4, 4.5, and 4.7 of
  261        * <cite>The Java&trade; Virtual Machine Specification</cite>
  262        */
  263   
  264       /**
  265        * The {@code int} value representing the {@code public}
  266        * modifier.
  267        */
  268       public static final int PUBLIC           = 0x00000001;
  269   
  270       /**
  271        * The {@code int} value representing the {@code private}
  272        * modifier.
  273        */
  274       public static final int PRIVATE          = 0x00000002;
  275   
  276       /**
  277        * The {@code int} value representing the {@code protected}
  278        * modifier.
  279        */
  280       public static final int PROTECTED        = 0x00000004;
  281   
  282       /**
  283        * The {@code int} value representing the {@code static}
  284        * modifier.
  285        */
  286       public static final int STATIC           = 0x00000008;
  287   
  288       /**
  289        * The {@code int} value representing the {@code final}
  290        * modifier.
  291        */
  292       public static final int FINAL            = 0x00000010;
  293   
  294       /**
  295        * The {@code int} value representing the {@code synchronized}
  296        * modifier.
  297        */
  298       public static final int SYNCHRONIZED     = 0x00000020;
  299   
  300       /**
  301        * The {@code int} value representing the {@code volatile}
  302        * modifier.
  303        */
  304       public static final int VOLATILE         = 0x00000040;
  305   
  306       /**
  307        * The {@code int} value representing the {@code transient}
  308        * modifier.
  309        */
  310       public static final int TRANSIENT        = 0x00000080;
  311   
  312       /**
  313        * The {@code int} value representing the {@code native}
  314        * modifier.
  315        */
  316       public static final int NATIVE           = 0x00000100;
  317   
  318       /**
  319        * The {@code int} value representing the {@code interface}
  320        * modifier.
  321        */
  322       public static final int INTERFACE        = 0x00000200;
  323   
  324       /**
  325        * The {@code int} value representing the {@code abstract}
  326        * modifier.
  327        */
  328       public static final int ABSTRACT         = 0x00000400;
  329   
  330       /**
  331        * The {@code int} value representing the {@code strictfp}
  332        * modifier.
  333        */
  334       public static final int STRICT           = 0x00000800;
  335   
  336       // Bits not (yet) exposed in the public API either because they
  337       // have different meanings for fields and methods and there is no
  338       // way to distinguish between the two in this class, or because
  339       // they are not Java programming language keywords
  340       static final int BRIDGE    = 0x00000040;
  341       static final int VARARGS   = 0x00000080;
  342       static final int SYNTHETIC = 0x00001000;
  343       static final int ANNOTATION= 0x00002000;
  344       static final int ENUM      = 0x00004000;
  345       static boolean isSynthetic(int mod) {
  346         return (mod & SYNTHETIC) != 0;
  347       }
  348   
  349       /**
  350        * See JLSv3 section 8.1.1.
  351        */
  352       private static final int CLASS_MODIFIERS =
  353           Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
  354           Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
  355           Modifier.STRICT;
  356   
  357       /**
  358        * See JLSv3 section 9.1.1.
  359        */
  360       private static final int INTERFACE_MODIFIERS =
  361           Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
  362           Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.STRICT;
  363   
  364   
  365       /**
  366        * See JLSv3 section 8.8.3.
  367        */
  368       private static final int CONSTRUCTOR_MODIFIERS =
  369           Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE;
  370   
  371       /**
  372        * See JLSv3 section 8.4.3.
  373        */
  374       private static final int METHOD_MODIFIERS =
  375           Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
  376           Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
  377           Modifier.SYNCHRONIZED   | Modifier.NATIVE       | Modifier.STRICT;
  378   
  379       /**
  380        * See JLSv3 section 8.3.1.
  381        */
  382       private static final int FIELD_MODIFIERS =
  383           Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
  384           Modifier.STATIC         | Modifier.FINAL        | Modifier.TRANSIENT |
  385           Modifier.VOLATILE;
  386   
  387       /**
  388        * Return an {@code int} value OR-ing together the source language
  389        * modifiers that can be applied to a class.
  390        * @return an {@code int} value OR-ing together the source language
  391        * modifiers that can be applied to a class.
  392        *
  393        * @jls 8.1.1 Class Modifiers
  394        * @since 1.7
  395        */
  396       public static int classModifiers() {
  397           return CLASS_MODIFIERS;
  398       }
  399   
  400       /**
  401        * Return an {@code int} value OR-ing together the source language
  402        * modifiers that can be applied to an interface.
  403        * @return an {@code int} value OR-ing together the source language
  404        * modifiers that can be applied to an inteface.
  405        *
  406        * @jls 9.1.1 Interface Modifiers
  407        * @since 1.7
  408        */
  409       public static int interfaceModifiers() {
  410           return INTERFACE_MODIFIERS;
  411       }
  412   
  413       /**
  414        * Return an {@code int} value OR-ing together the source language
  415        * modifiers that can be applied to a constructor.
  416        * @return an {@code int} value OR-ing together the source language
  417        * modifiers that can be applied to a constructor.
  418        *
  419        * @jls 8.8.3 Constructor Modifiers
  420        * @since 1.7
  421        */
  422       public static int constructorModifiers() {
  423           return CONSTRUCTOR_MODIFIERS;
  424       }
  425   
  426       /**
  427        * Return an {@code int} value OR-ing together the source language
  428        * modifiers that can be applied to a method.
  429        * @return an {@code int} value OR-ing together the source language
  430        * modifiers that can be applied to a method.
  431        *
  432        * @jls 8.4.3 Method Modifiers
  433        * @since 1.7
  434        */
  435       public static int methodModifiers() {
  436           return METHOD_MODIFIERS;
  437       }
  438   
  439   
  440       /**
  441        * Return an {@code int} value OR-ing together the source language
  442        * modifiers that can be applied to a field.
  443        * @return an {@code int} value OR-ing together the source language
  444        * modifiers that can be applied to a field.
  445        *
  446        * @jls 8.3.1 Field Modifiers
  447        * @since 1.7
  448        */
  449       public static int fieldModifiers() {
  450           return FIELD_MODIFIERS;
  451       }
  452   }

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