| /dalvik/vm/native/ |
| java_lang_reflect_Constructor.cpp | 25 * public int constructNative(Object[] args, Class declaringClass,
39 ClassObject* declaringClass = (ClassObject*) args[2];
46 if (dvmIsAbstractClass(declaringClass)) {
47 dvmThrowInstantiationException(declaringClass, NULL);
52 if (!dvmIsClassInitialized(declaringClass)) {
53 if (!dvmInitClass(declaringClass)) {
55 declaringClass->descriptor);
61 newObj = dvmAllocObject(declaringClass, ALLOC_DEFAULT);
65 meth = dvmSlotToMethod(declaringClass, slot);
|
| java_lang_reflect_Method.cpp | 33 ClassObject* declaringClass = (ClassObject*) args[0];
37 meth = dvmSlotToMethod(declaringClass, slot);
42 * private Object invokeNative(Object obj, Object[] args, Class declaringClass,
53 ClassObject* declaringClass = (ClassObject*) args[3];
65 meth = dvmSlotToMethod(declaringClass, slot);
69 if (!dvmIsClassInitialized(declaringClass)) {
70 if (!dvmInitClass(declaringClass))
75 if (dvmIsInterfaceClass(declaringClass) &&
76 !dvmIsClassInitialized(declaringClass))
78 if (!dvmInitClass(declaringClass))
[all...] |
| java_lang_reflect_Field.cpp | 27 * "declaringClass" is the class in which the field was declared. For an
58 static Field* validateFieldAccess(Object* obj, ClassObject* declaringClass,
63 field = dvmSlotToField(declaringClass, slot);
98 samePackage = dvmInSamePackage(declaringClass, callerClass);
110 if (!dvmIsClassInitialized(declaringClass)) {
111 if (!dvmInitClass(declaringClass)) {
123 if (!dvmVerifyObjectInClass(obj, declaringClass)) {
434 * public int getFieldModifiers(Class declaringClass, int slot)
440 ClassObject* declaringClass = (ClassObject*) args[1];
444 field = dvmSlotToField(declaringClass, slot)
[all...] |
| /libcore/libart/src/main/java/java/lang/reflect/ |
| ArtField.java | 42 private Class<?> declaringClass;
70 if (!declaringClass.isProxy()) {
75 Dex dex = declaringClass.getDex();
77 return declaringClass.getDexCacheString(dex, nameIndex);
81 return declaringClass;
87 if (!declaringClass.isProxy()) {
92 Dex dex = declaringClass.getDex();
94 return declaringClass.getDexCacheType(dex, typeIndex);
|
| ArtMethod.java | 47 private Class<?> declaringClass;
81 return declaringClass;
143 Dex dex = declaringClass.getDex();
172 return AnnotationAccess.getParameterAnnotations(declaringClass, methodDexIndex);
197 resolvedType = declaringClass.getDexCacheType(dex, dexTypeIndex);
210 if (declaringClass.isProxy()) {
|
| AbstractMethod.java | 269 Class<?> declaringClass = ((Member) this).getDeclaringClass();
272 Types.appendTypeName(sb, declaringClass);
278 Types.appendTypeName(sb, declaringClass);
|
| Field.java | 212 Class<?> declaringClass = getDeclaringClass();
213 ClassLoader cl = declaringClass.getClassLoader();
215 parser.parseForField(declaringClass, signatureAttribute);
[all...] |
| /libcore/libdvm/src/main/java/java/lang/reflect/ |
| Field.java | 64 private Class<?> declaringClass;
94 private Field(Class<?> declaringClass, Class<?> type, String name, int slot, int fieldDexIndex) {
95 this.declaringClass = declaringClass;
114 declaringClass.getClassLoader());
115 parser.parseForField(this.declaringClass, signatureAttribute);
127 Object[] annotation = getSignatureAnnotation(declaringClass, slot);
139 native private Object[] getSignatureAnnotation(Class declaringClass, int slot);
147 int flags = getFieldModifiers(declaringClass, slot);
179 int flags = getFieldModifiers(declaringClass, slot)
[all...] |
| Method.java | 85 private Class<?> declaringClass;
105 declaringClass.getClassLoader());
116 this.declaringClass = declaring;
137 Object[] annotation = getSignatureAnnotation(declaringClass, slot);
150 static native Object[] getSignatureAnnotation(Class declaringClass, int slot);
258 return getDeclaredAnnotations(declaringClass, slot);
260 static native Annotation[] getDeclaredAnnotations(Class<?> declaringClass, int slot);
266 return getAnnotation(declaringClass, slot, annotationType);
269 Class<?> declaringClass, int slot, Class<A> annotationType);
275 return isAnnotationPresent(declaringClass, slot, annotationType)
[all...] |
| Constructor.java | 51 Class<T> declaringClass;
66 declaringClass.getClassLoader());
90 * @param declaringClass
99 private Constructor(Class<T> declaringClass, Class<?>[] ptypes, Class<?>[] extypes, int slot, int methodDexIndex) {
100 this.declaringClass = declaringClass;
113 Object[] annotation = Method.getSignatureAnnotation(declaringClass, slot);
209 return Method.getDeclaredAnnotations(declaringClass, slot);
216 return Method.getAnnotation(declaringClass, slot, annotationType);
223 return Method.isAnnotationPresent(declaringClass, slot, annotationType)
[all...] |
| /external/mockito/src/org/mockito/internal/invocation/ |
| SerializableMethod.java | 17 private Class<?> declaringClass;
25 declaringClass = method.getDeclaringClass();
55 return declaringClass.getDeclaredMethod(methodName, parameterTypes);
59 "Please report this as a defect with an example of how to reproduce it.", declaringClass, methodName);
64 "Please report this as a defect with an example of how to reproduce it.", declaringClass, methodName);
83 if (declaringClass == null) {
84 if (other.declaringClass != null)
86 } else if (!declaringClass.equals(other.declaringClass))
|
| /cts/tools/signature-tools/src/signature/model/impl/ |
| SigExecutableMember.java | 40 private IClassDefinition declaringClass = Uninitialized.unset();
84 return declaringClass;
87 public void setDeclaringClass(IClassDefinition declaringClass) {
88 this.declaringClass = declaringClass;
|
| SigClassDefinition.java | 51 private IClassDefinition declaringClass = Uninitialized.unset();
134 return declaringClass;
137 public void setDeclaringClass(IClassDefinition declaringClass) {
138 this.declaringClass = declaringClass;
|
| /cts/tools/dex-tools/src/dex/reader/ |
| DexFieldImpl.java | 39 private final DexClass declaringClass;
42 public DexFieldImpl(DexBuffer buffer, DexClass declaringClass,
47 this.declaringClass = declaringClass;
86 return declaringClass;
|
| DexMethodImpl.java | 49 private final DexClass declaringClass;
54 public DexMethodImpl(DexBuffer buffer, DexClass declaringClass,
60 this.declaringClass = declaringClass;
136 return declaringClass;
|
| /libcore/luni/src/main/java/java/lang/ |
| StackTraceElement.java | 35 String declaringClass;
66 declaringClass = cls;
143 return (declaringClass == null) ? "<unknown class>" : declaringClass;
182 * Either both methodName and declaringClass are null, or neither are
189 // declaringClass never null if methodName is non-null
190 return methodName.hashCode() ^ declaringClass.hashCode();
|
| /external/javassist/src/main/javassist/ |
| CtMember.java | 24 protected CtClass declaringClass;
127 declaringClass = clazz;
164 public CtClass getDeclaringClass() { return declaringClass; }
174 return clazz == declaringClass;
176 String declName = declaringClass.getPackageName();
185 return clazz.subclassOf(declaringClass);
|
| CtMethod.java | 208 declaringClass.checkModify();
254 setBody0(src.declaringClass, src.methodInfo,
255 declaringClass, methodInfo, map);
272 declaringClass.checkModify();
|
| CtBehavior.java | 43 CtClass declaring = declaringClass;
98 declaringClass.checkModify();
144 declaringClass.checkModify();
286 declaringClass.getClassPool());
294 declaringClass.getClassPool());
335 return declaringClass.getClassPool().get(exceptions);
342 declaringClass.checkModify();
394 CtClass cc = declaringClass;
406 declaringClass.rebuildClassFile();
474 declaringClass.checkModify()
[all...] |
| CtConstructor.java | 140 return declaringClass.getSimpleName();
175 ClassFile cf = declaringClass.getClassFile2();
234 setBody0(src.declaringClass, src.methodInfo,
235 declaringClass, methodInfo, map);
247 CtClass cc = declaringClass;
|
| /packages/inputmethods/LatinIME/tools/dicttool/src/com/android/inputmethod/latin/dicttool/ |
| Test.java | 90 final Class<?> declaringClass = m.getDeclaringClass();
99 twoArgsConstructor = declaringClass.getDeclaredConstructor(Long.TYPE, Integer.TYPE);
103 final Object instance = null == twoArgsConstructor ? declaringClass.newInstance()
|
| /external/robolectric/src/main/java/com/xtremelabs/robolectric/bytecode/ |
| ShadowWrangler.java | 373 Class<?> declaringClass = findDeclaringClassForMethod(methodName, paramClasses, originalClass);
374 return findShadowClass(declaringClass, classLoader);
378 Class<?> declaringClass;
380 declaringClass = originalClass;
388 declaringClass = originalMethod.getDeclaringClass();
390 return declaringClass;
422 Class<?> declaringClass = method.getDeclaringClass();
424 // It doesn't work because the method and declaringClass were loaded by the delegate class loader. Different classloaders so types don't match. mp 20110823
425 for (Annotation annotation : declaringClass.getAnnotations()) {
|
| /libcore/luni/src/main/java/libcore/reflect/ |
| AnnotationAccess.java | 268 public static int getFieldIndex(Class<?> declaringClass, Class<?> type, String name) {
269 Dex dex = declaringClass.getDex();
270 int declaringClassIndex = getTypeIndex(dex, declaringClass);
277 public static int getMethodIndex(Class<?> declaringClass, String name, int protoIndex) {
278 Dex dex = declaringClass.getDex();
279 int declaringClassIndex = getTypeIndex(dex, declaringClass);
288 public static Annotation[][] getParameterAnnotations(Class<?> declaringClass,
290 Dex dex = declaringClass.getDex();
297 int directoryOffset = declaringClass.getDexAnnotationDirectoryOffset();
331 = annotationSetToAnnotations(declaringClass, annotationSetOffset)
[all...] |
| /external/jmonkeyengine/engine/src/core/com/jme3/export/ |
| SavableClassUtil.java | 107 Class<? extends Savable> declaringClass = (Class<? extends Savable>) field.getDeclaringClass();
108 if (declaringClass == clazz){
|
| /cts/tools/signature-tools/src/signature/converter/dex/ |
| DexToSigConverter.java | 235 IClassDefinition declaringClass = sigClass.getDeclaringClass();
237 .get(getDexName(declaringClass));
608 SigClassDefinition declaringClass = factory.getClass(
610 constructor.setDeclaringClass(declaringClass);
651 if (declaringClass.getDeclaringClass() != null) {
652 if (!declaringClass.getModifiers().contains(Modifier.STATIC)) {
658 String enclosingName = declaringClass.getDeclaringClass()
[all...] |
