feat: 大规模扩充至212个模块/175K行代码 — 覆盖android/java/javax/org/dalvik全包
- android/ 167个模块 (app/content/os/view/widget/graphics/media/hardware/net/telephony/provider等) - java/ 35个模块 (lang/io/util/net/nio/security/crypto/sql/beans/rmi/awt等) - javax/ 4个模块 (net/crypto/security/sql) - org/ 5个模块 (json/w3c_dom/xml_sax/xml_pull/apache_http) - dalvik/ 1个模块 (system) - ~3053个类/接口，方法签名完全对齐Android SDK - 桌面跨平台运行 (Windows/macOS/Linux) - 修复所有导入错误和Python关键字冲突
This commit is contained in:
shuiyu1123 committed
1 parent
506f9ac725
commit
a51854455b
128 files changed
+100571
-3
No files matched your search
@@ -0,0 +1,968 @@
|
||||
"""
|
||||
Java java.lang.reflect APIs implemented in Python.
|
||||
java.lang.reflect package - Field, Method, Constructor, Array, Modifier, Proxy, etc.
|
||||
Wraps Python inspect module.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from .._core import Stub, AndroidOnlyError
|
||||
import inspect as _inspect
|
||||
import types as _types
|
||||
from typing import Any, List, Optional, Tuple
|
||||
|
||||
__all__ = [
|
||||
"Field", "Method", "Constructor", "Array", "Modifier",
|
||||
"InvocationHandler", "Proxy", "Parameter",
|
||||
"AccessibleObject", "Executable",
|
||||
"GenericArrayType", "ParameterizedType", "TypeVariable",
|
||||
"WildcardType", "GenericDeclaration",
|
||||
"AnnotatedType", "AnnotatedArrayType", "AnnotatedParameterizedType",
|
||||
"AnnotatedTypeVariable", "AnnotatedWildcardType",
|
||||
]
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Modifier
|
||||
# ============================================================
|
||||
|
||||
class Modifier(Stub):
|
||||
"""
|
||||
java.lang.reflect.Modifier
|
||||
Provides static methods and constants for decoding class and member access modifiers.
|
||||
Uses actual JVM modifier bit values.
|
||||
"""
|
||||
PUBLIC: int = 0x0001
|
||||
PRIVATE: int = 0x0002
|
||||
PROTECTED: int = 0x0004
|
||||
STATIC: int = 0x0008
|
||||
FINAL: int = 0x0010
|
||||
SYNCHRONIZED: int = 0x0020
|
||||
VOLATILE: int = 0x0040
|
||||
TRANSIENT: int = 0x0080
|
||||
NATIVE: int = 0x0100
|
||||
INTERFACE: int = 0x0200
|
||||
ABSTRACT: int = 0x0400
|
||||
STRICT: int = 0x0800
|
||||
|
||||
_MODIFIER_NAMES = {
|
||||
0x0001: "public", 0x0002: "private", 0x0004: "protected",
|
||||
0x0008: "static", 0x0010: "final", 0x0020: "synchronized",
|
||||
0x0040: "volatile", 0x0080: "transient", 0x0100: "native",
|
||||
0x0200: "interface", 0x0400: "abstract", 0x0800: "strictfp",
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
|
||||
@staticmethod
|
||||
def isPublic(mod: int) -> bool:
|
||||
return (mod & Modifier.PUBLIC) != 0
|
||||
|
||||
@staticmethod
|
||||
def isPrivate(mod: int) -> bool:
|
||||
return (mod & Modifier.PRIVATE) != 0
|
||||
|
||||
@staticmethod
|
||||
def isProtected(mod: int) -> bool:
|
||||
return (mod & Modifier.PROTECTED) != 0
|
||||
|
||||
@staticmethod
|
||||
def isStatic(mod: int) -> bool:
|
||||
return (mod & Modifier.STATIC) != 0
|
||||
|
||||
@staticmethod
|
||||
def isFinal(mod: int) -> bool:
|
||||
return (mod & Modifier.FINAL) != 0
|
||||
|
||||
@staticmethod
|
||||
def isSynchronized(mod: int) -> bool:
|
||||
return (mod & Modifier.SYNCHRONIZED) != 0
|
||||
|
||||
@staticmethod
|
||||
def isVolatile(mod: int) -> bool:
|
||||
return (mod & Modifier.VOLATILE) != 0
|
||||
|
||||
@staticmethod
|
||||
def isTransient(mod: int) -> bool:
|
||||
return (mod & Modifier.TRANSIENT) != 0
|
||||
|
||||
@staticmethod
|
||||
def isNative(mod: int) -> bool:
|
||||
return (mod & Modifier.NATIVE) != 0
|
||||
|
||||
@staticmethod
|
||||
def isInterface(mod: int) -> bool:
|
||||
return (mod & Modifier.INTERFACE) != 0
|
||||
|
||||
@staticmethod
|
||||
def isAbstract(mod: int) -> bool:
|
||||
return (mod & Modifier.ABSTRACT) != 0
|
||||
|
||||
@staticmethod
|
||||
def isStrict(mod: int) -> bool:
|
||||
return (mod & Modifier.STRICT) != 0
|
||||
|
||||
@staticmethod
|
||||
def toString(mod: int) -> str:
|
||||
parts = []
|
||||
for bit, name in sorted(Modifier._MODIFIER_NAMES.items()):
|
||||
if mod & bit:
|
||||
parts.append(name)
|
||||
return " ".join(parts)
|
||||
|
||||
@staticmethod
|
||||
def classModifiers() -> int:
|
||||
return Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE | \
|
||||
Modifier.ABSTRACT | Modifier.STATIC | Modifier.FINAL | Modifier.STRICT
|
||||
|
||||
@staticmethod
|
||||
def constructorModifiers() -> int:
|
||||
return Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE
|
||||
|
||||
@staticmethod
|
||||
def fieldModifiers() -> int:
|
||||
return Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE | \
|
||||
Modifier.STATIC | Modifier.FINAL | Modifier.TRANSIENT | Modifier.VOLATILE
|
||||
|
||||
@staticmethod
|
||||
def interfaceModifiers() -> int:
|
||||
return Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE | \
|
||||
Modifier.ABSTRACT | Modifier.STATIC | Modifier.STRICT
|
||||
|
||||
@staticmethod
|
||||
def methodModifiers() -> int:
|
||||
return Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE | \
|
||||
Modifier.ABSTRACT | Modifier.STATIC | Modifier.FINAL | \
|
||||
Modifier.SYNCHRONIZED | Modifier.NATIVE | Modifier.STRICT
|
||||
|
||||
@staticmethod
|
||||
def parameterModifiers() -> int:
|
||||
return Modifier.FINAL
|
||||
|
||||
|
||||
# ============================================================
|
||||
# AccessibleObject
|
||||
# ============================================================
|
||||
|
||||
class AccessibleObject(Stub):
|
||||
"""
|
||||
java.lang.reflect.AccessibleObject
|
||||
Base class for Field, Method, and Constructor.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self._accessible = False
|
||||
|
||||
def setAccessible(self, flag: bool):
|
||||
"""Sets the accessible flag for this object."""
|
||||
self._accessible = flag
|
||||
|
||||
def isAccessible(self) -> bool:
|
||||
"""Returns the value of the accessible flag."""
|
||||
return self._accessible
|
||||
|
||||
def getAnnotation(self, annotation_class: type) -> Optional[Stub]:
|
||||
"""Returns the annotation for this element (if present)."""
|
||||
return None
|
||||
|
||||
def getDeclaredAnnotations(self) -> List:
|
||||
"""Returns all annotations directly present on this element."""
|
||||
return []
|
||||
|
||||
def getAnnotations(self) -> List:
|
||||
"""Returns all annotations on this element."""
|
||||
return []
|
||||
|
||||
def getAnnotationsByType(self, annotation_class: type) -> List:
|
||||
"""Returns annotations of the specified type on this element."""
|
||||
return []
|
||||
|
||||
def isAnnotationPresent(self, annotation_class: type) -> bool:
|
||||
"""Returns True if the specified annotation is present."""
|
||||
return False
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"{self.__class__.__name__}@{hex(id(self))}"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return self is other
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Field
|
||||
# ============================================================
|
||||
|
||||
class Field(AccessibleObject):
|
||||
"""
|
||||
java.lang.reflect.Field
|
||||
Provides information about, and dynamic access to, a single field of a class.
|
||||
"""
|
||||
|
||||
def __init__(self, declaring_class: type = None, name: str = None,
|
||||
field_type: type = None, modifiers: int = 0):
|
||||
super().__init__()
|
||||
self._declaring_class = declaring_class
|
||||
self._name = name
|
||||
self._field_type = field_type
|
||||
self._modifiers = modifiers
|
||||
self._generic_type = field_type
|
||||
|
||||
def getName(self) -> str:
|
||||
return self._name or ""
|
||||
|
||||
def getType(self) -> type:
|
||||
return self._field_type or object
|
||||
|
||||
def getModifiers(self) -> int:
|
||||
return self._modifiers
|
||||
|
||||
def get(self, obj: Any) -> Any:
|
||||
"""Returns the value of the field on the given object."""
|
||||
if self._name is None:
|
||||
return None
|
||||
if obj is None and Modifier.isStatic(self._modifiers):
|
||||
# Static field access on the class
|
||||
if self._declaring_class and hasattr(self._declaring_class, self._name):
|
||||
return getattr(self._declaring_class, self._name)
|
||||
return None
|
||||
if obj is not None and hasattr(obj, self._name):
|
||||
return getattr(obj, self._name)
|
||||
return None
|
||||
|
||||
def set(self, obj: Any, value: Any):
|
||||
"""Sets the field on the given object to the given value."""
|
||||
if self._name is None:
|
||||
return
|
||||
if obj is None and Modifier.isStatic(self._modifiers):
|
||||
if self._declaring_class:
|
||||
setattr(self._declaring_class, self._name, value)
|
||||
return
|
||||
if obj is not None and hasattr(obj, self._name):
|
||||
setattr(obj, self._name, value)
|
||||
|
||||
def setAccessible(self, flag: bool):
|
||||
self._accessible = flag
|
||||
|
||||
def getDeclaringClass(self) -> type:
|
||||
return self._declaring_class
|
||||
|
||||
def getGenericType(self):
|
||||
return self._generic_type
|
||||
|
||||
def getAnnotation(self, annotation_class: type):
|
||||
return None
|
||||
|
||||
def getDeclaredAnnotations(self) -> List:
|
||||
return []
|
||||
|
||||
def isAccessible(self) -> bool:
|
||||
return self._accessible
|
||||
|
||||
def isSynthetic(self) -> bool:
|
||||
return False
|
||||
|
||||
def toGenericString(self) -> str:
|
||||
return f"{Modifier.toString(self._modifiers)} {self._field_type.__name__ if self._field_type else '?'} {self._name}"
|
||||
|
||||
def getBoolean(self, obj: Any) -> bool:
|
||||
val = self.get(obj)
|
||||
return bool(val) if val is not None else False
|
||||
|
||||
def getByte(self, obj: Any) -> int:
|
||||
val = self.get(obj)
|
||||
return int(val) if val is not None else 0
|
||||
|
||||
def getChar(self, obj: Any) -> str:
|
||||
val = self.get(obj)
|
||||
return str(val)[0] if val else '\0'
|
||||
|
||||
def getShort(self, obj: Any) -> int:
|
||||
val = self.get(obj)
|
||||
return int(val) if val is not None else 0
|
||||
|
||||
def getInt(self, obj: Any) -> int:
|
||||
val = self.get(obj)
|
||||
return int(val) if val is not None else 0
|
||||
|
||||
def getLong(self, obj: Any) -> int:
|
||||
val = self.get(obj)
|
||||
return int(val) if val is not None else 0
|
||||
|
||||
def getFloat(self, obj: Any) -> float:
|
||||
val = self.get(obj)
|
||||
return float(val) if val is not None else 0.0
|
||||
|
||||
def getDouble(self, obj: Any) -> float:
|
||||
val = self.get(obj)
|
||||
return float(val) if val is not None else 0.0
|
||||
|
||||
def setBoolean(self, obj: Any, value: bool):
|
||||
self.set(obj, value)
|
||||
|
||||
def setByte(self, obj: Any, value: int):
|
||||
self.set(obj, value)
|
||||
|
||||
def setChar(self, obj: Any, value: str):
|
||||
self.set(obj, value)
|
||||
|
||||
def setShort(self, obj: Any, value: int):
|
||||
self.set(obj, value)
|
||||
|
||||
def setInt(self, obj: Any, value: int):
|
||||
self.set(obj, value)
|
||||
|
||||
def setLong(self, obj: Any, value: int):
|
||||
self.set(obj, value)
|
||||
|
||||
def setFloat(self, obj: Any, value: float):
|
||||
self.set(obj, value)
|
||||
|
||||
def setDouble(self, obj: Any, value: float):
|
||||
self.set(obj, value)
|
||||
|
||||
def toString(self) -> str:
|
||||
return self.toGenericString()
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
if not isinstance(other, Field):
|
||||
return False
|
||||
return (self._declaring_class == other._declaring_class and
|
||||
self._name == other._name and
|
||||
self._field_type == other._field_type)
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash((self._declaring_class, self._name)) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Executable (abstract base for Method & Constructor)
|
||||
# ============================================================
|
||||
|
||||
class Executable(AccessibleObject):
|
||||
"""
|
||||
java.lang.reflect.Executable
|
||||
Shared base for Method and Constructor.
|
||||
"""
|
||||
|
||||
def __init__(self, declaring_class: type = None, name: str = None,
|
||||
parameter_types: List[type] = None, exception_types: List[type] = None,
|
||||
modifiers: int = 0):
|
||||
super().__init__()
|
||||
self._declaring_class = declaring_class
|
||||
self._name = name
|
||||
self._parameter_types = parameter_types or []
|
||||
self._exception_types = exception_types or []
|
||||
self._modifiers = modifiers
|
||||
|
||||
def getParameterTypes(self) -> List[type]:
|
||||
return list(self._parameter_types)
|
||||
|
||||
def getParameterCount(self) -> int:
|
||||
return len(self._parameter_types)
|
||||
|
||||
def getExceptionTypes(self) -> List[type]:
|
||||
return list(self._exception_types)
|
||||
|
||||
def getModifiers(self) -> int:
|
||||
return self._modifiers
|
||||
|
||||
def getDeclaringClass(self) -> type:
|
||||
return self._declaring_class
|
||||
|
||||
def getName(self) -> str:
|
||||
return self._name or ""
|
||||
|
||||
def getAnnotation(self, annotation_class: type):
|
||||
return None
|
||||
|
||||
def getDeclaredAnnotations(self) -> List:
|
||||
return []
|
||||
|
||||
def getParameterAnnotations(self) -> List[List]:
|
||||
return [[] for _ in self._parameter_types]
|
||||
|
||||
def isVarArgs(self) -> bool:
|
||||
return False
|
||||
|
||||
def isSynthetic(self) -> bool:
|
||||
return False
|
||||
|
||||
def toGenericString(self) -> str:
|
||||
return f"{Modifier.toString(self._modifiers)} {self._name}({', '.join(t.__name__ for t in self._parameter_types)})"
|
||||
|
||||
def toString(self) -> str:
|
||||
return self.toGenericString()
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
if not isinstance(other, Executable):
|
||||
return False
|
||||
return (self._declaring_class == other._declaring_class and
|
||||
self._name == other._name and
|
||||
self._parameter_types == other._parameter_types)
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash((self._declaring_class, self._name)) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Method
|
||||
# ============================================================
|
||||
|
||||
class Method(Executable):
|
||||
"""
|
||||
java.lang.reflect.Method
|
||||
Provides information about, and access to, a single method of a class.
|
||||
"""
|
||||
|
||||
def __init__(self, declaring_class: type = None, name: str = None,
|
||||
return_type: type = None, parameter_types: List[type] = None,
|
||||
exception_types: List[type] = None, modifiers: int = 0,
|
||||
impl_func: callable = None):
|
||||
super().__init__(declaring_class, name, parameter_types, exception_types, modifiers)
|
||||
self._return_type = return_type
|
||||
self._impl_func = impl_func
|
||||
self._generic_return_type = return_type
|
||||
self._generic_parameter_types = parameter_types or []
|
||||
|
||||
def getReturnType(self) -> type:
|
||||
return self._return_type or type(None)
|
||||
|
||||
def getGenericReturnType(self):
|
||||
return self._generic_return_type
|
||||
|
||||
def getGenericParameterTypes(self) -> List:
|
||||
return list(self._generic_parameter_types)
|
||||
|
||||
def invoke(self, obj: Any, *args) -> Any:
|
||||
"""
|
||||
Invokes the underlying method on the given object with the given args.
|
||||
"""
|
||||
if self._impl_func is not None:
|
||||
return self._impl_func(obj, *args)
|
||||
|
||||
if self._name is None:
|
||||
return None
|
||||
|
||||
# Try to call the method on the object
|
||||
if obj is not None and hasattr(obj, self._name):
|
||||
method = getattr(obj, self._name)
|
||||
if callable(method):
|
||||
return method(*args)
|
||||
|
||||
# Static call on class
|
||||
if self._declaring_class and hasattr(self._declaring_class, self._name):
|
||||
method = getattr(self._declaring_class, self._name)
|
||||
if callable(method):
|
||||
return method(*args)
|
||||
|
||||
return None
|
||||
|
||||
def getDefaultValue(self):
|
||||
"""Returns the default value for the annotation member."""
|
||||
return None
|
||||
|
||||
def isBridge(self) -> bool:
|
||||
return False
|
||||
|
||||
def toGenericString(self) -> str:
|
||||
ret = self._return_type.__name__ if self._return_type else "void"
|
||||
params = ', '.join(t.__name__ for t in self._parameter_types)
|
||||
return f"{Modifier.toString(self._modifiers)} {ret} {self._name}({params})"
|
||||
|
||||
def toString(self) -> str:
|
||||
return self.toGenericString()
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
if not isinstance(other, Method):
|
||||
return False
|
||||
return (self._declaring_class == other._declaring_class and
|
||||
self._name == other._name and
|
||||
self._parameter_types == other._parameter_types)
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash((self._declaring_class, self._name)) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Constructor
|
||||
# ============================================================
|
||||
|
||||
class Constructor(Executable):
|
||||
"""
|
||||
java.lang.reflect.Constructor
|
||||
Provides information about, and access to, a single constructor of a class.
|
||||
"""
|
||||
|
||||
def __init__(self, declaring_class: type = None,
|
||||
parameter_types: List[type] = None,
|
||||
exception_types: List[type] = None,
|
||||
modifiers: int = 0):
|
||||
super().__init__(declaring_class, declaring_class.__name__ if declaring_class else "<init>",
|
||||
parameter_types, exception_types, modifiers)
|
||||
|
||||
def newInstance(self, *args) -> Any:
|
||||
"""Creates a new instance of the declaring class."""
|
||||
if self._declaring_class is None:
|
||||
raise AndroidOnlyError("No declaring class for constructor")
|
||||
try:
|
||||
return self._declaring_class(*args)
|
||||
except Exception as e:
|
||||
raise AndroidOnlyError(f"Cannot instantiate {self._declaring_class}: {e}")
|
||||
|
||||
def toGenericString(self) -> str:
|
||||
params = ', '.join(t.__name__ for t in self._parameter_types)
|
||||
return f"{Modifier.toString(self._modifiers)} {self._name}({params})"
|
||||
|
||||
def toString(self) -> str:
|
||||
return self.toGenericString()
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
if not isinstance(other, Constructor):
|
||||
return False
|
||||
return (self._declaring_class == other._declaring_class and
|
||||
self._parameter_types == other._parameter_types)
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash((self._declaring_class, tuple(self._parameter_types))) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Array
|
||||
# ============================================================
|
||||
|
||||
class Array(Stub):
|
||||
"""
|
||||
java.lang.reflect.Array
|
||||
Provides static methods to dynamically create and access arrays.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
|
||||
@staticmethod
|
||||
def newInstance(component_type: type, *dimensions) -> Any:
|
||||
"""Creates a new array with the specified component type and dimensions."""
|
||||
if len(dimensions) == 1:
|
||||
return [None] * dimensions[0]
|
||||
# Multi-dimensional
|
||||
result = []
|
||||
for _ in range(dimensions[0]):
|
||||
result.append(Array.newInstance(component_type, *dimensions[1:]))
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def getLength(array: Any) -> int:
|
||||
"""Returns the length of the specified array."""
|
||||
return len(array)
|
||||
|
||||
@staticmethod
|
||||
def get(array: Any, index: int) -> Any:
|
||||
"""Returns the element at the specified index."""
|
||||
return array[index]
|
||||
|
||||
@staticmethod
|
||||
def set(array: Any, index: int, value: Any):
|
||||
"""Sets the element at the specified index."""
|
||||
array[index] = value
|
||||
|
||||
@staticmethod
|
||||
def getBoolean(array: Any, index: int) -> bool:
|
||||
return bool(array[index])
|
||||
|
||||
@staticmethod
|
||||
def getByte(array: Any, index: int) -> int:
|
||||
return int(array[index])
|
||||
|
||||
@staticmethod
|
||||
def getChar(array: Any, index: int) -> str:
|
||||
return str(array[index])
|
||||
|
||||
@staticmethod
|
||||
def getShort(array: Any, index: int) -> int:
|
||||
return int(array[index])
|
||||
|
||||
@staticmethod
|
||||
def getInt(array: Any, index: int) -> int:
|
||||
return int(array[index])
|
||||
|
||||
@staticmethod
|
||||
def getLong(array: Any, index: int) -> int:
|
||||
return int(array[index])
|
||||
|
||||
@staticmethod
|
||||
def getFloat(array: Any, index: int) -> float:
|
||||
return float(array[index])
|
||||
|
||||
@staticmethod
|
||||
def getDouble(array: Any, index: int) -> float:
|
||||
return float(array[index])
|
||||
|
||||
@staticmethod
|
||||
def setBoolean(array: Any, index: int, value: bool):
|
||||
array[index] = value
|
||||
|
||||
@staticmethod
|
||||
def setByte(array: Any, index: int, value: int):
|
||||
array[index] = value
|
||||
|
||||
@staticmethod
|
||||
def setChar(array: Any, index: int, value: str):
|
||||
array[index] = value
|
||||
|
||||
@staticmethod
|
||||
def setShort(array: Any, index: int, value: int):
|
||||
array[index] = value
|
||||
|
||||
@staticmethod
|
||||
def setInt(array: Any, index: int, value: int):
|
||||
array[index] = value
|
||||
|
||||
@staticmethod
|
||||
def setLong(array: Any, index: int, value: int):
|
||||
array[index] = value
|
||||
|
||||
@staticmethod
|
||||
def setFloat(array: Any, index: int, value: float):
|
||||
array[index] = value
|
||||
|
||||
@staticmethod
|
||||
def setDouble(array: Any, index: int, value: float):
|
||||
array[index] = value
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Parameter
|
||||
# ============================================================
|
||||
|
||||
class Parameter(AccessibleObject):
|
||||
"""
|
||||
java.lang.reflect.Parameter
|
||||
Information about a method parameter.
|
||||
"""
|
||||
|
||||
def __init__(self, name: str = None, param_type: type = None,
|
||||
modifiers: int = 0, is_implicit: bool = False,
|
||||
is_name_present: bool = True):
|
||||
super().__init__()
|
||||
self._name = name or ""
|
||||
self._param_type = param_type or object
|
||||
self._modifiers = modifiers
|
||||
self._is_implicit = is_implicit
|
||||
self._is_name_present = is_name_present
|
||||
self._parameterized_type = param_type
|
||||
|
||||
def getName(self) -> str:
|
||||
return self._name
|
||||
|
||||
def getType(self) -> type:
|
||||
return self._param_type
|
||||
|
||||
def getParameterizedType(self):
|
||||
return self._parameterized_type
|
||||
|
||||
def getModifiers(self) -> int:
|
||||
return self._modifiers
|
||||
|
||||
def isNamePresent(self) -> bool:
|
||||
return self._is_name_present
|
||||
|
||||
def isImplicit(self) -> bool:
|
||||
return self._is_implicit
|
||||
|
||||
def isSynthetic(self) -> bool:
|
||||
return False
|
||||
|
||||
def isVarArgs(self) -> bool:
|
||||
return False
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"{Modifier.toString(self._modifiers)} {self._param_type.__name__} {self._name}"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
if not isinstance(other, Parameter):
|
||||
return False
|
||||
return (self._name == other._name and
|
||||
self._param_type == other._param_type)
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash((self._name, self._param_type)) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# InvocationHandler
|
||||
# ============================================================
|
||||
|
||||
class InvocationHandler(Stub):
|
||||
"""
|
||||
java.lang.reflect.InvocationHandler
|
||||
Interface for invocation handlers of proxy instances.
|
||||
"""
|
||||
|
||||
def invoke(self, proxy: Any, method: Any, args: List) -> Any:
|
||||
"""Processes a method invocation on a proxy instance."""
|
||||
raise NotImplementedError("invoke must be implemented by subclass")
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Proxy
|
||||
# ============================================================
|
||||
|
||||
class Proxy(Stub):
|
||||
"""
|
||||
java.lang.reflect.Proxy
|
||||
Provides static methods for creating dynamic proxy classes and instances.
|
||||
"""
|
||||
|
||||
_invocation_handler: InvocationHandler = None
|
||||
|
||||
def __init__(self, handler: InvocationHandler = None):
|
||||
super().__init__()
|
||||
self._invocation_handler = handler
|
||||
|
||||
@staticmethod
|
||||
def newProxyInstance(class_loader: Any, interfaces: List[type],
|
||||
handler: InvocationHandler) -> Stub:
|
||||
"""Creates a proxy instance for the specified interfaces."""
|
||||
proxy = Proxy(handler)
|
||||
proxy._interfaces = interfaces
|
||||
return proxy
|
||||
|
||||
@staticmethod
|
||||
def getInvocationHandler(proxy: Any) -> InvocationHandler:
|
||||
"""Returns the invocation handler for the specified proxy instance."""
|
||||
if isinstance(proxy, Proxy):
|
||||
return proxy._invocation_handler
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def getProxyClass(class_loader: Any, interfaces: List[type]) -> type:
|
||||
"""Returns the proxy class for the specified interfaces."""
|
||||
return Proxy
|
||||
|
||||
@staticmethod
|
||||
def isProxyClass(cls: type) -> bool:
|
||||
"""Returns True if the class is a proxy class."""
|
||||
return cls == Proxy or (hasattr(cls, '__bases__') and Proxy in cls.__bases__)
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"Proxy@{hex(id(self))}"
|
||||
|
||||
def equals(self, other) -> bool:
|
||||
return self is other
|
||||
|
||||
def hashCode(self) -> int:
|
||||
return hash(self) & 0x7FFFFFFF
|
||||
|
||||
|
||||
# ============================================================
|
||||
# Generic Array Type (stub interface)
|
||||
# ============================================================
|
||||
|
||||
class GenericArrayType(Stub):
|
||||
"""
|
||||
java.lang.reflect.GenericArrayType
|
||||
Represents an array type whose component type is a parameterized type or type variable.
|
||||
"""
|
||||
def __init__(self, generic_component_type=None):
|
||||
super().__init__()
|
||||
self._generic_component_type = generic_component_type
|
||||
|
||||
def getGenericComponentType(self):
|
||||
return self._generic_component_type
|
||||
|
||||
def toString(self) -> str:
|
||||
return f"{self._generic_component_type}[]"
|
||||
|
||||
|
||||
# ============================================================
|
||||
# ParameterizedType
|
||||
# ============================================================
|
||||
|
||||
class ParameterizedType(Stub):
|
||||
"""
|
||||
java.lang.reflect.ParameterizedType
|
||||
Represents a parameterized type, e.g. List<String>.
|
||||
"""
|
||||
def __init__(self, raw_type=None, actual_type_arguments=None, owner_type=None):
|
||||
super().__init__()
|
||||
self._raw_type = raw_type
|
||||
self._actual_type_arguments = actual_type_arguments or []
|
||||
self._owner_type = owner_type
|
||||
|
||||
def getRawType(self):
|
||||
return self._raw_type
|
||||
|
||||
def getActualTypeArguments(self):
|
||||
return list(self._actual_type_arguments)
|
||||
|
||||
def getOwnerType(self):
|
||||
return self._owner_type
|
||||
|
||||
def toString(self) -> str:
|
||||
args = ', '.join(str(a) for a in self._actual_type_arguments)
|
||||
return f"{self._raw_type}<{args}>"
|
||||
|
||||
|
||||
# ============================================================
|
||||
# TypeVariable
|
||||
# ============================================================
|
||||
|
||||
class TypeVariable(Stub):
|
||||
"""
|
||||
java.lang.reflect.TypeVariable
|
||||
Represents a type variable, like T in Foo<T>.
|
||||
"""
|
||||
def __init__(self, name: str = None, bounds: List = None,
|
||||
generic_declaration: Any = None):
|
||||
super().__init__()
|
||||
self._name = name or "T"
|
||||
self._bounds = bounds or [object]
|
||||
self._generic_declaration = generic_declaration
|
||||
|
||||
def getName(self) -> str:
|
||||
return self._name
|
||||
|
||||
def getBounds(self) -> List:
|
||||
return list(self._bounds)
|
||||
|
||||
def getGenericDeclaration(self) -> Any:
|
||||
return self._generic_declaration
|
||||
|
||||
def toString(self) -> str:
|
||||
return self._name
|
||||
|
||||
|
||||
# ============================================================
|
||||
# WildcardType
|
||||
# ============================================================
|
||||
|
||||
class WildcardType(Stub):
|
||||
"""
|
||||
java.lang.reflect.WildcardType
|
||||
Represents a wildcard type, like ?, ? extends T, ? super T.
|
||||
"""
|
||||
def __init__(self, upper_bounds: List = None, lower_bounds: List = None):
|
||||
super().__init__()
|
||||
self._upper_bounds = upper_bounds or [object]
|
||||
self._lower_bounds = lower_bounds or []
|
||||
|
||||
def getUpperBounds(self) -> List:
|
||||
return list(self._upper_bounds)
|
||||
|
||||
def getLowerBounds(self) -> List:
|
||||
return list(self._lower_bounds)
|
||||
|
||||
def toString(self) -> str:
|
||||
if self._lower_bounds:
|
||||
return f"? super {self._lower_bounds[0]}"
|
||||
if self._upper_bounds and self._upper_bounds[0] is not object:
|
||||
return f"? extends {self._upper_bounds[0]}"
|
||||
return "?"
|
||||
|
||||
|
||||
# ============================================================
|
||||
# GenericDeclaration
|
||||
# ============================================================
|
||||
|
||||
class GenericDeclaration(Stub):
|
||||
"""
|
||||
java.lang.reflect.GenericDeclaration
|
||||
Interface for entities that declare type variables.
|
||||
"""
|
||||
def getTypeParameters(self) -> List[TypeVariable]:
|
||||
return []
|
||||
|
||||
def toGenericString(self) -> str:
|
||||
return self.toString()
|
||||
|
||||
|
||||
# ============================================================
|
||||
# AnnotatedType interfaces
|
||||
# ============================================================
|
||||
|
||||
class AnnotatedType(Stub):
|
||||
"""
|
||||
java.lang.reflect.AnnotatedType
|
||||
Represents an annotated type.
|
||||
"""
|
||||
def __init__(self, type_=None, annotations: List = None):
|
||||
super().__init__()
|
||||
self._type = type_
|
||||
self._annotations = annotations or []
|
||||
|
||||
def getType(self):
|
||||
return self._type
|
||||
|
||||
def getAnnotations(self) -> List:
|
||||
return list(self._annotations)
|
||||
|
||||
def getAnnotation(self, annotation_class: type):
|
||||
for a in self._annotations:
|
||||
if isinstance(a, annotation_class):
|
||||
return a
|
||||
return None
|
||||
|
||||
def toString(self) -> str:
|
||||
return str(self._type) if self._type else "?"
|
||||
|
||||
|
||||
class AnnotatedArrayType(AnnotatedType):
|
||||
"""
|
||||
java.lang.reflect.AnnotatedArrayType
|
||||
Represents an annotated array type.
|
||||
"""
|
||||
def __init__(self, annotated_generic_component_type=None, type_=None, annotations=None):
|
||||
super().__init__(type_, annotations)
|
||||
self._annotated_generic_component_type = annotated_generic_component_type
|
||||
|
||||
def getAnnotatedGenericComponentType(self) -> AnnotatedType:
|
||||
return self._annotated_generic_component_type
|
||||
|
||||
|
||||
class AnnotatedParameterizedType(AnnotatedType):
|
||||
"""
|
||||
java.lang.reflect.AnnotatedParameterizedType
|
||||
Represents an annotated parameterized type.
|
||||
"""
|
||||
def __init__(self, annotated_actual_type_arguments=None, type_=None, annotations=None):
|
||||
super().__init__(type_, annotations)
|
||||
self._annotated_actual_type_arguments = annotated_actual_type_arguments or []
|
||||
|
||||
def getAnnotatedActualTypeArguments(self) -> List[AnnotatedType]:
|
||||
return list(self._annotated_actual_type_arguments)
|
||||
|
||||
|
||||
class AnnotatedTypeVariable(AnnotatedType):
|
||||
"""
|
||||
java.lang.reflect.AnnotatedTypeVariable
|
||||
Represents an annotated type variable.
|
||||
"""
|
||||
def __init__(self, annotated_bounds=None, type_=None, annotations=None):
|
||||
super().__init__(type_, annotations)
|
||||
self._annotated_bounds = annotated_bounds or []
|
||||
|
||||
def getAnnotatedBounds(self) -> List[AnnotatedType]:
|
||||
return list(self._annotated_bounds)
|
||||
|
||||
|
||||
class AnnotatedWildcardType(AnnotatedType):
|
||||
"""
|
||||
java.lang.reflect.AnnotatedWildcardType
|
||||
Represents an annotated wildcard type.
|
||||
"""
|
||||
def __init__(self, annotated_upper_bounds=None, annotated_lower_bounds=None,
|
||||
type_=None, annotations=None):
|
||||
super().__init__(type_, annotations)
|
||||
self._annotated_upper_bounds = annotated_upper_bounds or []
|
||||
self._annotated_lower_bounds = annotated_lower_bounds or []
|
||||
|
||||
def getAnnotatedUpperBounds(self) -> List[AnnotatedType]:
|
||||
return list(self._annotated_upper_bounds)
|
||||
|
||||
def getAnnotatedLowerBounds(self) -> List[AnnotatedType]:
|
||||
return list(self._annotated_lower_bounds)
|
||||
Reference in new issue
Block a user