Code cleanup

src/accessmasks.rs

@@ -0,0 +1,107 @@
+use core::fmt::{Display, Formatter, Debug};
+
+#[derive(Debug, Copy, Clone)] 
+pub enum MethodAccessFlag {
+    Public       = 0x0001,    // Declared public; may be accessed from outside its package.
+    Private      = 0x0002,    // Declared private; accessible only within the defining class and other classes belonging to the same nest (§5.4.4).
+    Protected    = 0x0004,    // Declared protected; may be accessed within subclasses.
+    Static       = 0x0008,    // Declared static.
+    Final        = 0x0010,    // Declared final; must not be overridden (§5.4.5).
+    Synchronized = 0x0020,    // Declared synchronized; invocation is wrapped by a monitor use.
+    Bridge       = 0x0040,    // A bridge method, generated by the compiler.
+    Varargs      = 0x0080,    // Declared with variable number of arguments.
+    Native       = 0x0100,    // Declared native; implemented in a language other than the Java programming language.
+    Abstract     = 0x0400,    // Declared abstract; no implementation is provided.
+    Strict       = 0x0800,    // In a class file whose major version number is at least 46 and at most 60: Declared strict.
+    Synthetic    = 0x1000,    // Declared synthetic; not present in the source code.
+}
+
+pub struct MethodAccessFlagMask {
+    pub mask: u16,
+}
+
+impl Debug for MethodAccessFlagMask {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let mut flag_vec = Vec::new();
+
+        let flags = [MethodAccessFlag::Public,MethodAccessFlag::Private,MethodAccessFlag::Protected,MethodAccessFlag::Static,MethodAccessFlag::Final,MethodAccessFlag::Synchronized,MethodAccessFlag::Bridge,MethodAccessFlag::Varargs,MethodAccessFlag::Native,MethodAccessFlag::Abstract,MethodAccessFlag::Strict,MethodAccessFlag::Synthetic];
+
+        for flag in flags {
+            if (flag as u16 & self.mask) != 0 {
+                flag_vec.push(flag)
+            }
+        }
+
+        f.debug_list().entries(flag_vec)
+            .finish()
+    }
+}
+
+#[derive(Debug, Copy, Clone)] 
+pub enum ClassAccessFlag {
+    Public        = 0x0001, //  Declared public; may be accessed from outside its package.
+    Final         = 0x0010, //  Declared final; no subclasses allowed.
+    Super         = 0x0020, //  Treat superclass methods specially when invoked by the invokespecial instruction.
+    Interface     = 0x0200, //  Is an interface, not a class.
+    Abstract      = 0x0400, //  Declared abstract; must not be instantiated.
+    Synthetic     = 0x1000, //  Declared synthetic; not present in the source code.
+    Annotation    = 0x2000, //  Declared as an annotation interface.
+    Enum          = 0x4000, //  Declared as an enum class.
+    Module        = 0x8000, //  Is a module, not a class or interface.
+}
+
+pub struct ClassAccessFlagMask {
+    pub mask: u16,
+}
+
+impl Debug for ClassAccessFlagMask {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let mut flag_vec = Vec::new();
+
+        let flags = [ClassAccessFlag::Public,ClassAccessFlag::Final,ClassAccessFlag::Super,ClassAccessFlag::Interface,ClassAccessFlag::Abstract,ClassAccessFlag::Synthetic,ClassAccessFlag::Annotation,ClassAccessFlag::Enum,ClassAccessFlag::Module];
+        for flag in flags {
+            if (flag as u16 & self.mask) != 0 {
+                flag_vec.push(flag)
+            }
+        }
+
+        f.debug_list().entries(flag_vec)
+            .finish()
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(u16)]
+pub enum FieldAccessFlag {
+    Public    = 0x0001, // 	Declared public; may be accessed from outside its package.
+    Private   = 0x0002, // 	Declared private; accessible only within the defining class and other classes belonging to the same nest (§5.4.4).
+    Protected = 0x0004, // 	Declared protected; may be accessed within subclasses.
+    Static    = 0x0008, // 	Declared static.
+    Final     = 0x0010, // 	Declared final; never directly assigned to after object construction (JLS §17.5).
+    Volatile  = 0x0040, // 	Declared volatile; cannot be cached.
+    Transient = 0x0080, // 	Declared transient; not written or read by a persistent object manager.
+    Synthetic = 0x1000, // 	Declared synthetic; not present in the source code.
+    Enum      = 0x4000, // 	Declared as an element of an enum class. 
+ }
+
+ pub struct FieldAccessFlagMask {
+     pub mask: u16
+ }
+
+impl Debug for FieldAccessFlagMask {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
+        let mut flag_vec = Vec::new();
+
+        let flags = [FieldAccessFlag::Public,FieldAccessFlag::Private,FieldAccessFlag::Protected,FieldAccessFlag::Static,FieldAccessFlag::Final,FieldAccessFlag::Volatile,FieldAccessFlag::Transient,FieldAccessFlag::Synthetic,FieldAccessFlag::Enum,];
+
+        for flag in flags {
+            if (flag as u16 & self.mask) != 0 {
+                flag_vec.push(flag)
+            }
+        }
+
+        f.debug_list().entries(flag_vec)
+            .finish()
+    }
+}
+