Enum AccessFlag

pub enum AccessFlag {
    Abstract,
    Annotation,
    Bridge,
    Enum,
    Final,
    Interface,
    Mandated,
    Module,
    Native,
    Open,
    Public,
    Private,
    Protected,
    Static,
    StaticPhase,
    Strict,
    Super,
    Synchronized,
    Synthetic,
    Transient,
    Transitive,
    VarArgs,
    Volatile,
}

Variants

Abstract

• class: Declared abstract; must not be instantiated.
• inner class: Marked or implicitly abstract in source.
• method: Declared abstract; no implementation is provided.

Annotation

• class: Declared as an annotation type.
• inner class: Declared as an annotation type.

Bridge

• method: A bridge method, generated by the compiler.

Enum

• class: Declared as an enum type.
• inner class: Declared as an enum type.
• field: Declared as an element of an enum.

Final

• class: Declared final; no subclasses allowed.
• inner class: Marked final in source.
• field: Declared final; never directly assigned to after object construction.
• method: Declared final; must not be overridden
• formal parameter: Indicates that the formal parameter was declared final.

Interface

• class: Is an interface, not a class.
• inner class: Was an interface in source.

Mandated

• formal parameter: Indicates that the formal parameter was implicitly declared in source code, according to the specification of the language in which the source code was written.
• module: Indicates that this module was implicitly declared.
• module requires/exports/opens flag: Indicates that this dependence was implicitly declared in the source of the module declaration.

Module

• class: Is a module, not a class or interface.

Native

• method: Declared native; implemented in a language other than Java.

Open

• module: Indicates that this module is open.

Public

• class: Declared public; may be accessed from outside its package.
• inner class: Marked or implicitly public in source.
• field, method: Declared public; may be accessed from outside its package.

Private

• inner class: Marked private in source.
• field, method: Declared private; accessible only within the defining class.

Protected

• inner class: Marked protected in source.
• field, method: Declared protected; may be accessed within subclasses.

Static

• inner class: Marked or implicitly static in source.
• field, method: Declared static.

StaticPhase

• module requires flag: Indicates that this dependence is mandatory in the static phase, i.e., at compile time, but is optional in the dynamic phase, i.e., at run time.

Strict

• method: Declared strictfp; floating-point mode is FP-strict.

Super

• class: Treat superclass methods specially when invoked by the invokespecial instruction.

Synchronized

• method: Declared synchronized; invocation is wrapped by a monitor use.

Synthetic

Declared synthetic; not present in the source code.

Transient

• field: Declared transient; not written or read by a persistent object manager.

Transitive

• module requires flag: Indicates that any module which depends on the current module, implicitly declares a dependence on the module indicated by this entry.

VarArgs

• method: Declared with variable number of arguments.

Volatile

• field: Declared volatile; cannot be cached.

Trait Implementations

impl Clone for AccessFlag

fn clone(&self) -> AccessFlag

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AccessFlag

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for AccessFlag

fn eq(&self, other: &AccessFlag) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for AccessFlag

impl StructuralPartialEq for AccessFlag