1 /*
   2  * Copyright (c) 1996, 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 
  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 final int MANDATED  = 0x00008000;
 346     static boolean isSynthetic(int mod) {
 347       return (mod & SYNTHETIC) != 0;
 348     }
 349 
 350     static boolean isMandated(int mod) {
 351       return (mod & MANDATED) != 0;
 352     }
 353 
 354     /**
 355      * See JLSv3 section 8.1.1.
 356      */
 357     private static final int CLASS_MODIFIERS =
 358         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
 359         Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
 360         Modifier.STRICT;
 361 
 362     /**
 363      * See JLSv3 section 9.1.1.
 364      */
 365     private static final int INTERFACE_MODIFIERS =
 366         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
 367         Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.STRICT;
 368 
 369 
 370     /**
 371      * See JLSv3 section 8.8.3.
 372      */
 373     private static final int CONSTRUCTOR_MODIFIERS =
 374         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE;
 375 
 376     /**
 377      * See JLSv3 section 8.4.3.
 378      */
 379     private static final int METHOD_MODIFIERS =
 380         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
 381         Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
 382         Modifier.SYNCHRONIZED   | Modifier.NATIVE       | Modifier.STRICT;
 383 
 384     /**
 385      * See JLSv3 section 8.3.1.
 386      */
 387     private static final int FIELD_MODIFIERS =
 388         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
 389         Modifier.STATIC         | Modifier.FINAL        | Modifier.TRANSIENT |
 390         Modifier.VOLATILE;
 391 
 392     /**
 393      * Return an {@code int} value OR-ing together the source language
 394      * modifiers that can be applied to a class.
 395      * @return an {@code int} value OR-ing together the source language
 396      * modifiers that can be applied to a class.
 397      *
 398      * @jls 8.1.1 Class Modifiers
 399      * @since 1.7
 400      */
 401     public static int classModifiers() {
 402         return CLASS_MODIFIERS;
 403     }
 404 
 405     /**
 406      * Return an {@code int} value OR-ing together the source language
 407      * modifiers that can be applied to an interface.
 408      * @return an {@code int} value OR-ing together the source language
 409      * modifiers that can be applied to an inteface.
 410      *
 411      * @jls 9.1.1 Interface Modifiers
 412      * @since 1.7
 413      */
 414     public static int interfaceModifiers() {
 415         return INTERFACE_MODIFIERS;
 416     }
 417 
 418     /**
 419      * Return an {@code int} value OR-ing together the source language
 420      * modifiers that can be applied to a constructor.
 421      * @return an {@code int} value OR-ing together the source language
 422      * modifiers that can be applied to a constructor.
 423      *
 424      * @jls 8.8.3 Constructor Modifiers
 425      * @since 1.7
 426      */
 427     public static int constructorModifiers() {
 428         return CONSTRUCTOR_MODIFIERS;
 429     }
 430 
 431     /**
 432      * Return an {@code int} value OR-ing together the source language
 433      * modifiers that can be applied to a method.
 434      * @return an {@code int} value OR-ing together the source language
 435      * modifiers that can be applied to a method.
 436      *
 437      * @jls 8.4.3 Method Modifiers
 438      * @since 1.7
 439      */
 440     public static int methodModifiers() {
 441         return METHOD_MODIFIERS;
 442     }
 443 
 444 
 445     /**
 446      * Return an {@code int} value OR-ing together the source language
 447      * modifiers that can be applied to a field.
 448      * @return an {@code int} value OR-ing together the source language
 449      * modifiers that can be applied to a field.
 450      *
 451      * @jls 8.3.1 Field Modifiers
 452      * @since 1.7
 453      */
 454     public static int fieldModifiers() {
 455         return FIELD_MODIFIERS;
 456     }
 457 }