1 /*
   2  * Copyright (c) 1996, 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 java.security.AccessController;
  29 import java.util.StringJoiner;
  30 import jdk.internal.reflect.LangReflectAccess;
  31 import jdk.internal.reflect.ReflectionFactory;
  32 
  33 /**
  34  * The Modifier class provides {@code static} methods and
  35  * constants to decode class and member access modifiers.  The sets of
  36  * modifiers are represented as integers with distinct bit positions
  37  * representing different modifiers.  The values for the constants
  38  * representing the modifiers are taken from the tables in sections 4.1, 4.4, 4.5, and 4.7 of
  39  * <cite>The Java&trade; Virtual Machine Specification</cite>.
  40  *
  41  * @see Class#getModifiers()
  42  * @see Member#getModifiers()
  43  *
  44  * @author Nakul Saraiya
  45  * @author Kenneth Russell
  46  * @since 1.1
  47  */
  48 public class Modifier {
  49 
  50     /*
  51      * Bootstrapping protocol between java.lang and java.lang.reflect
  52      *  packages
  53      */
  54     static {
  55         ReflectionFactory factory = 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         StringJoiner sj = new StringJoiner(" ");
 237 
 238         if ((mod & PUBLIC) != 0)        sj.add("public");
 239         if ((mod & PROTECTED) != 0)     sj.add("protected");
 240         if ((mod & PRIVATE) != 0)       sj.add("private");
 241 
 242         /* Canonical order */
 243         if ((mod & ABSTRACT) != 0)      sj.add("abstract");
 244         if ((mod & STATIC) != 0)        sj.add("static");
 245         if ((mod & FINAL) != 0)         sj.add("final");
 246         if ((mod & TRANSIENT) != 0)     sj.add("transient");
 247         if ((mod & VOLATILE) != 0)      sj.add("volatile");
 248         if ((mod & SYNCHRONIZED) != 0)  sj.add("synchronized");
 249         if ((mod & NATIVE) != 0)        sj.add("native");
 250         if ((mod & STRICT) != 0)        sj.add("strictfp");
 251         if ((mod & INTERFACE) != 0)     sj.add("interface");
 252 
 253         return sj.toString();
 254     }
 255 
 256     /*
 257      * Access modifier flag constants from tables 4.1, 4.4, 4.5, and 4.7 of
 258      * <cite>The Java&trade; Virtual Machine Specification</cite>
 259      */
 260 
 261     /**
 262      * The {@code int} value representing the {@code public}
 263      * modifier.
 264      */
 265     public static final int PUBLIC           = 0x00000001;
 266 
 267     /**
 268      * The {@code int} value representing the {@code private}
 269      * modifier.
 270      */
 271     public static final int PRIVATE          = 0x00000002;
 272 
 273     /**
 274      * The {@code int} value representing the {@code protected}
 275      * modifier.
 276      */
 277     public static final int PROTECTED        = 0x00000004;
 278 
 279     /**
 280      * The {@code int} value representing the {@code static}
 281      * modifier.
 282      */
 283     public static final int STATIC           = 0x00000008;
 284 
 285     /**
 286      * The {@code int} value representing the {@code final}
 287      * modifier.
 288      */
 289     public static final int FINAL            = 0x00000010;
 290 
 291     /**
 292      * The {@code int} value representing the {@code synchronized}
 293      * modifier.
 294      */
 295     public static final int SYNCHRONIZED     = 0x00000020;
 296 
 297     /**
 298      * The {@code int} value representing the {@code volatile}
 299      * modifier.
 300      */
 301     public static final int VOLATILE         = 0x00000040;
 302 
 303     /**
 304      * The {@code int} value representing the {@code transient}
 305      * modifier.
 306      */
 307     public static final int TRANSIENT        = 0x00000080;
 308 
 309     /**
 310      * The {@code int} value representing the {@code native}
 311      * modifier.
 312      */
 313     public static final int NATIVE           = 0x00000100;
 314 
 315     /**
 316      * The {@code int} value representing the {@code interface}
 317      * modifier.
 318      */
 319     public static final int INTERFACE        = 0x00000200;
 320 
 321     /**
 322      * The {@code int} value representing the {@code abstract}
 323      * modifier.
 324      */
 325     public static final int ABSTRACT         = 0x00000400;
 326 
 327     /**
 328      * The {@code int} value representing the {@code strictfp}
 329      * modifier.
 330      */
 331     public static final int STRICT           = 0x00000800;
 332 
 333     // Bits not (yet) exposed in the public API either because they
 334     // have different meanings for fields and methods and there is no
 335     // way to distinguish between the two in this class, or because
 336     // they are not Java programming language keywords
 337     static final int BRIDGE      = 0x00000040;
 338     static final int VARARGS     = 0x00000080;
 339     static final int SYNTHETIC   = 0x00001000;
 340     static final int ANNOTATION  = 0x00002000;
 341     static final int ENUM        = 0x00004000;
 342     static final int MANDATED    = 0x00008000;
 343     static final int FLATTENED   = 0x00008000;      // HotSpot-specific bit
 344     static boolean isSynthetic(int mod) {
 345       return (mod & SYNTHETIC) != 0;
 346     }
 347 
 348     static boolean isMandated(int mod) {
 349       return (mod & MANDATED) != 0;
 350     }
 351 
 352     // Note on the FOO_MODIFIERS fields and fooModifiers() methods:
 353     // the sets of modifiers are not guaranteed to be constants
 354     // across time and Java SE releases. Therefore, it would not be
 355     // appropriate to expose an external interface to this information
 356     // that would allow the values to be treated as Java-level
 357     // constants since the values could be constant folded and updates
 358     // to the sets of modifiers missed. Thus, the fooModifiers()
 359     // methods return an unchanging values for a given release, but a
 360     // value that can potentially change over time.
 361 
 362     /**
 363      * The Java source modifiers that can be applied to a class.
 364      * @jls 8.1.1 Class Modifiers
 365      */
 366     private static final int CLASS_MODIFIERS =
 367         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
 368         Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
 369         Modifier.STRICT;
 370 
 371     /**
 372      * The Java source modifiers that can be applied to an interface.
 373      * @jls 9.1.1 Interface Modifiers
 374      */
 375     private static final int INTERFACE_MODIFIERS =
 376         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
 377         Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.STRICT;
 378 
 379 
 380     /**
 381      * The Java source modifiers that can be applied to a constructor.
 382      * @jls 8.8.3 Constructor Modifiers
 383      */
 384     private static final int CONSTRUCTOR_MODIFIERS =
 385         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE;
 386 
 387     /**
 388      * The Java source modifiers that can be applied to a method.
 389      * @jls8.4.3  Method Modifiers
 390      */
 391     private static final int METHOD_MODIFIERS =
 392         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
 393         Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
 394         Modifier.SYNCHRONIZED   | Modifier.NATIVE       | Modifier.STRICT;
 395 
 396     /**
 397      * The Java source modifiers that can be applied to a field.
 398      * @jls 8.3.1 Field Modifiers
 399      */
 400     private static final int FIELD_MODIFIERS =
 401         Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
 402         Modifier.STATIC         | Modifier.FINAL        | Modifier.TRANSIENT |
 403         Modifier.VOLATILE;
 404 
 405     /**
 406      * The Java source modifiers that can be applied to a method or constructor parameter.
 407      * @jls 8.4.1 Formal Parameters
 408      */
 409     private static final int PARAMETER_MODIFIERS =
 410         Modifier.FINAL;
 411 
 412     /**
 413      *
 414      */
 415     static final int ACCESS_MODIFIERS =
 416         Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE;
 417 
 418     /**
 419      * Return an {@code int} value OR-ing together the source language
 420      * modifiers that can be applied to a class.
 421      * @return an {@code int} value OR-ing together the source language
 422      * modifiers that can be applied to a class.
 423      *
 424      * @jls 8.1.1 Class Modifiers
 425      * @since 1.7
 426      */
 427     public static int classModifiers() {
 428         return CLASS_MODIFIERS;
 429     }
 430 
 431     /**
 432      * Return an {@code int} value OR-ing together the source language
 433      * modifiers that can be applied to an interface.
 434      * @return an {@code int} value OR-ing together the source language
 435      * modifiers that can be applied to an interface.
 436      *
 437      * @jls 9.1.1 Interface Modifiers
 438      * @since 1.7
 439      */
 440     public static int interfaceModifiers() {
 441         return INTERFACE_MODIFIERS;
 442     }
 443 
 444     /**
 445      * Return an {@code int} value OR-ing together the source language
 446      * modifiers that can be applied to a constructor.
 447      * @return an {@code int} value OR-ing together the source language
 448      * modifiers that can be applied to a constructor.
 449      *
 450      * @jls 8.8.3 Constructor Modifiers
 451      * @since 1.7
 452      */
 453     public static int constructorModifiers() {
 454         return CONSTRUCTOR_MODIFIERS;
 455     }
 456 
 457     /**
 458      * Return an {@code int} value OR-ing together the source language
 459      * modifiers that can be applied to a method.
 460      * @return an {@code int} value OR-ing together the source language
 461      * modifiers that can be applied to a method.
 462      *
 463      * @jls 8.4.3 Method Modifiers
 464      * @since 1.7
 465      */
 466     public static int methodModifiers() {
 467         return METHOD_MODIFIERS;
 468     }
 469 
 470     /**
 471      * Return an {@code int} value OR-ing together the source language
 472      * modifiers that can be applied to a field.
 473      * @return an {@code int} value OR-ing together the source language
 474      * modifiers that can be applied to a field.
 475      *
 476      * @jls 8.3.1 Field Modifiers
 477      * @since 1.7
 478      */
 479     public static int fieldModifiers() {
 480         return FIELD_MODIFIERS;
 481     }
 482 
 483     /**
 484      * Return an {@code int} value OR-ing together the source language
 485      * modifiers that can be applied to a parameter.
 486      * @return an {@code int} value OR-ing together the source language
 487      * modifiers that can be applied to a parameter.
 488      *
 489      * @jls 8.4.1 Formal Parameters
 490      * @since 1.8
 491      */
 492     public static int parameterModifiers() {
 493         return PARAMETER_MODIFIERS;
 494     }
 495 }