java.lang.reflect.Modifier Java Examples

The following examples show how to use java.lang.reflect.Modifier. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source Project: openjdk-jdk8u   Author: AdoptOpenJDK   File: ReflectUtil.java    License: GNU General Public License v2.0 6 votes vote down vote up
/**
 * Does a conservative approximation of member access check. Use this if
 * you don't have an actual 'userland' caller Class/ClassLoader available.
 * This might be more restrictive than a precise member access check where
 * you have a caller, but should never allow a member access that is
 * forbidden.
 *
 * @param m the {@code Member} about to be accessed
 */
public static void conservativeCheckMemberAccess(Member m) throws SecurityException{
    final SecurityManager sm = System.getSecurityManager();
    if (sm == null)
        return;

    // Check for package access on the declaring class.
    //
    // In addition, unless the member and the declaring class are both
    // public check for access declared member permissions.
    //
    // This is done regardless of ClassLoader relations between the {@code
    // Member m} and any potential caller.

    final Class<?> declaringClass = m.getDeclaringClass();

    checkPackageAccess(declaringClass);

    if (Modifier.isPublic(m.getModifiers()) &&
            Modifier.isPublic(declaringClass.getModifiers()))
        return;

    // Check for declared member access.
    sm.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
}
 
Example #2
Source Project: JDKSourceCode1.8   Author: wupeixuan   File: JMX.java    License: MIT License 6 votes vote down vote up
/**
 * <p>Test whether an interface is an MXBean interface.
 * An interface is an MXBean interface if it is public,
 * annotated {@link MXBean &#64;MXBean} or {@code @MXBean(true)}
 * or if it does not have an {@code @MXBean} annotation
 * and its name ends with "{@code MXBean}".</p>
 *
 * @param interfaceClass The candidate interface.
 *
 * @return true if {@code interfaceClass} is a
 * {@link javax.management.MXBean compliant MXBean interface}
 *
 * @throws NullPointerException if {@code interfaceClass} is null.
 */
public static boolean isMXBeanInterface(Class<?> interfaceClass) {
    if (!interfaceClass.isInterface())
        return false;
    if (!Modifier.isPublic(interfaceClass.getModifiers()) &&
        !Introspector.ALLOW_NONPUBLIC_MBEAN) {
        return false;
    }
    MXBean a = interfaceClass.getAnnotation(MXBean.class);
    if (a != null)
        return a.value();
    return interfaceClass.getName().endsWith("MXBean");
    // We don't bother excluding the case where the name is
    // exactly the string "MXBean" since that would mean there
    // was no package name, which is pretty unlikely in practice.
}
 
Example #3
Source Project: anyline   Author: anylineorg   File: BeanUtil.java    License: Apache License 2.0 6 votes vote down vote up
public static boolean setFieldValue(Object obj, Field field, Object value){ 
	if(null == obj || null == field){ 
		return false; 
	} 
	if(Modifier.isStatic(field.getModifiers())){ 
		return false; 
	} 
	try{
		if(field.isAccessible()){
			//可访问属性
			field.set(obj, value);
		}else{
			//不可访问属性
			field.setAccessible(true);
			field.set(obj, value);
			field.setAccessible(false);
		}
	}catch(Exception e){
		e.printStackTrace();
		return false;
	}
	return true; 
}
 
Example #4
Source Project: javageci   Author: verhas   File: Selector.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * -
 * <p>
 * ### Class and method checking selectors
 *
 * <p> These conditions work on classes and on methods. Applying
 * them on a field will throw exception.
 */
private void methodAndClassOnlySelectors() {
    /**
     * -
     *
     * * `abstract` is `true` if the type of method is abstract.
     *
     */
    selector("abstract", m -> only(m, Class.class, Method.class) && Modifier.isAbstract(getModifiers(m)));
    /**
     * -
     *
     * * `implements` is `true` if the class implements at least one
     * interface. When applied to a method it is `true` if the
     * method implements a method of the same name and argument
     * types in one of the interfaces the class directly or
     * indirectly implements. In other words it means that there is
     * an interface that declares this method and this method is an
     * implementation (not abstract).
     *
     */
    selector("implements", m -> only(m, Class.class, Method.class) && methodOrClassImplements(m));
}
 
Example #5
Source Project: jdk8u60   Author: chenghanpeng   File: JMX.java    License: GNU General Public License v2.0 6 votes vote down vote up
/**
 * <p>Test whether an interface is an MXBean interface.
 * An interface is an MXBean interface if it is public,
 * annotated {@link MXBean &#64;MXBean} or {@code @MXBean(true)}
 * or if it does not have an {@code @MXBean} annotation
 * and its name ends with "{@code MXBean}".</p>
 *
 * @param interfaceClass The candidate interface.
 *
 * @return true if {@code interfaceClass} is a
 * {@link javax.management.MXBean compliant MXBean interface}
 *
 * @throws NullPointerException if {@code interfaceClass} is null.
 */
public static boolean isMXBeanInterface(Class<?> interfaceClass) {
    if (!interfaceClass.isInterface())
        return false;
    if (!Modifier.isPublic(interfaceClass.getModifiers()) &&
        !Introspector.ALLOW_NONPUBLIC_MBEAN) {
        return false;
    }
    MXBean a = interfaceClass.getAnnotation(MXBean.class);
    if (a != null)
        return a.value();
    return interfaceClass.getName().endsWith("MXBean");
    // We don't bother excluding the case where the name is
    // exactly the string "MXBean" since that would mean there
    // was no package name, which is pretty unlikely in practice.
}
 
Example #6
Source Project: javageci   Author: verhas   File: GeciReflectionTools.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Convert an int containing modifiers bits to string containing the Java names of the modifiers space separated.
 *
 * @param modifiers to be converted to string
 * @return the space separated modifiers or empty string in case there is no modifier bit set in {@code modifiers}
 */
public static String unmask(int modifiers) {
    final StringBuilder s = new StringBuilder();
    final BiConsumer<Predicate<Integer>, String> check = (Predicate<Integer> predicate, String text) -> {
        if (predicate.test(modifiers)) {
            s.append(text);
        }
    };
    check.accept(Modifier::isPrivate, "private ");
    check.accept(Modifier::isProtected, "protected ");
    check.accept(Modifier::isPublic, "public ");
    check.accept(Modifier::isFinal, "final ");
    check.accept(Modifier::isStatic, "static ");
    check.accept(Modifier::isSynchronized, "synchronized ");
    check.accept(Modifier::isVolatile, "volatile ");
    check.accept(Modifier::isStrict, "strictfp ");
    check.accept(Modifier::isAbstract, "abstract ");
    check.accept(Modifier::isTransient, "transient ");
    return s.toString().trim();
}
 
Example #7
Source Project: poi-excel-utils   Author: hellojavaer   File: ExcelUtils.java    License: Apache License 2.0 6 votes vote down vote up
private static void readConfigParamVerify(ExcelReadSheetProcessor<?> sheetProcessor,
                                          Map<Integer, Map<String, ExcelReadFieldMappingAttribute>> fieldMapping) {
    Class<?> clazz = sheetProcessor.getTargetClass();

    for (Entry<Integer, Map<String, ExcelReadFieldMappingAttribute>> indexFieldMapping : fieldMapping.entrySet()) {
        for (Map.Entry<String, ExcelReadFieldMappingAttribute> filedMapping : indexFieldMapping.getValue().entrySet()) {
            String fieldName = filedMapping.getKey();
            if (fieldName != null) {
                PropertyDescriptor pd = getPropertyDescriptor(clazz, fieldName);
                if (pd == null || pd.getWriteMethod() == null) {
                    throw new IllegalArgumentException("In fieldMapping config {colIndex:"
                                                       + indexFieldMapping.getKey() + "["
                                                       + convertColIntIndexToCharIndex(indexFieldMapping.getKey())
                                                       + "]<->fieldName:" + filedMapping.getKey() + "}, "
                                                       + " class " + clazz.getName() + " can't find field '"
                                                       + filedMapping.getKey() + "' and can not also find "
                                                       + filedMapping.getKey() + "'s writter method.");
                }
                if (!Modifier.isPublic(pd.getWriteMethod().getDeclaringClass().getModifiers())) {
                    pd.getWriteMethod().setAccessible(true);
                }
            }
        }
    }
}
 
Example #8
Source Project: openjdk-jdk8u-backup   Author: AdoptOpenJDK   File: InvokerBytecodeGenerator.java    License: GNU General Public License v2.0 6 votes vote down vote up
static boolean isStaticallyNameable(Class<?> cls) {
    if (cls == Object.class)
        return true;
    while (cls.isArray())
        cls = cls.getComponentType();
    if (cls.isPrimitive())
        return true;  // int[].class, for example
    if (ReflectUtil.isVMAnonymousClass(cls)) // FIXME: switch to supported API once it is added
        return false;
    // could use VerifyAccess.isClassAccessible but the following is a safe approximation
    if (cls.getClassLoader() != Object.class.getClassLoader())
        return false;
    if (VerifyAccess.isSamePackage(MethodHandle.class, cls))
        return true;
    if (!Modifier.isPublic(cls.getModifiers()))
        return false;
    for (Class<?> pkgcls : STATICALLY_INVOCABLE_PACKAGES) {
        if (VerifyAccess.isSamePackage(pkgcls, cls))
            return true;
    }
    return false;
}
 
Example #9
Source Project: intellij-quarkus   Author: redhat-developer   File: ExternalSystemTestCase.java    License: Eclipse Public License 2.0 6 votes vote down vote up
private void resetClassFields(final Class<?> aClass) {
  if (aClass == null) return;

  final Field[] fields = aClass.getDeclaredFields();
  for (Field field : fields) {
    final int modifiers = field.getModifiers();
    if ((modifiers & Modifier.FINAL) == 0
        && (modifiers & Modifier.STATIC) == 0
        && !field.getType().isPrimitive()) {
      field.setAccessible(true);
      try {
        field.set(this, null);
      }
      catch (IllegalAccessException e) {
        e.printStackTrace();
      }
    }
  }

  if (aClass == ExternalSystemTestCase.class) return;
  resetClassFields(aClass.getSuperclass());
}
 
Example #10
Source Project: kogito-runtimes   Author: kiegroup   File: MVELConstraintBuilder.java    License: Apache License 2.0 6 votes vote down vote up
@Override
public boolean areEqualityCompatible(Class<?> c1, Class<?> c2) {
    if (c1 == NullType.class || c2 == NullType.class) {
        return true;
    }
    if (c1 == String.class || c2 == String.class) {
        return true;
    }
    Class<?> boxed1 = convertFromPrimitiveType(c1);
    Class<?> boxed2 = convertFromPrimitiveType(c2);
    if (boxed1.isAssignableFrom(boxed2) || boxed2.isAssignableFrom(boxed1)) {
        return true;
    }
    if (Number.class.isAssignableFrom(boxed1) && Number.class.isAssignableFrom(boxed2)) {
        return true;
    }
    return !Modifier.isFinal(c1.getModifiers()) && !Modifier.isFinal(c2.getModifiers());
}
 
Example #11
Source Project: mogu_blog_v2   Author: moxi624   File: JsonUtils.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * JSON 转 ArrayList
 *
 * @author [email protected]
 * @date 2018年10月27日下午4:43:25
 */
public static ArrayList<?> jsonArrayToArrayList(String jsonArray, Class<?> clazz) {

    Gson gson = new GsonBuilder()
            .excludeFieldsWithModifiers(Modifier.FINAL, Modifier.TRANSIENT, Modifier.STATIC)
            .setDateFormat("yyyy-MM-dd HH:mm:ss")
            .serializeNulls()
            .create();
    ArrayList<?> list = null;
    try {

        list = (ArrayList<?>) gson.fromJson(jsonArray, clazz);
    } catch (JsonSyntaxException e) {
        e.printStackTrace();
    }
    return list;
}
 
Example #12
Source Project: glowroot   Author: glowroot   File: AnalyzedMethod.java    License: Apache License 2.0 6 votes vote down vote up
boolean isOverriddenBy(String methodName, List<Type> parameterTypes) {
    if (Modifier.isStatic(modifiers())) {
        return false;
    }
    if (Modifier.isPrivate(modifiers())) {
        return false;
    }
    if (!methodName.equals(name())) {
        return false;
    }
    if (parameterTypes.size() != parameterTypes().size()) {
        return false;
    }
    for (int i = 0; i < parameterTypes.size(); i++) {
        if (!parameterTypes.get(i).getClassName().equals(parameterTypes().get(i))) {
            return false;
        }
    }
    return true;
}
 
Example #13
Source Project: spring-cloud-gcp   Author: spring-cloud   File: SpannerStructReadMethodCoverageTests.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void allKnownMappingTypesTest() throws NoSuchFieldException {
	for (Method method : Struct.class.getMethods()) {
		String methodName = method.getName();
		// ignoring private methods, ones not named like a getter. Getters must also
		// only take the column index or name
		if (!Modifier.isPublic(method.getModifiers()) || !methodName.startsWith("get")
				|| method.getParameterCount() != 1
				|| DISREGARDED_METHOD_NAMES.contains(methodName)) {
			continue;
		}
		Class returnType = ConversionUtils.boxIfNeeded(method.getReturnType());
		if (ConversionUtils.isIterableNonByteArrayType(returnType)) {
			Class innerReturnType = (Class) ((ParameterizedType) method
					.getGenericReturnType()).getActualTypeArguments()[0];
			assertThat(StructAccessor.readIterableMapping.keySet()).contains(innerReturnType);
		}
		else {
			assertThat(StructAccessor.singleItemReadMethodMapping.keySet()).contains(returnType);
		}
	}
}
 
Example #14
Source Project: Tangram-Android   Author: alibaba   File: ExposureSupport.java    License: MIT License 6 votes vote down vote up
private void findExposureMethods(Method[] methods) {
    for (Method method : methods) {
        String methodName = method.getName();
        if (isValidExposureMethodName(methodName)) {
            int modifiers = method.getModifiers();
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class<?>[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 3) {
                    Class<?> viewType = parameterTypes[0];
                    Class<?> cellType = parameterTypes[1];
                    Class<?> clickIntType = parameterTypes[2];
                    if (View.class.isAssignableFrom(viewType)
                            && BaseCell.class.isAssignableFrom(cellType)
                            && (clickIntType.equals(int.class) || clickIntType
                            .equals(Integer.class))) {
                        mOnExposureMethods.put(viewType, new OnTraceMethod(3, method));
                    }
                }
            }
        }
    }
}
 
Example #15
Source Project: Cubes   Author: ictrobot   File: LuaMapping.java    License: MIT License 6 votes vote down vote up
public static LuaTable mapping(Class<?> c) {
  try {
    LuaTable luaTable = new LuaTable();
    for (Field field : c.getFields()) {
      if (!Modifier.isStatic(field.getModifiers())) continue;
      if (LuaValue.class.isAssignableFrom(field.getType())) {
        luaTable.set(field.getName(), (LuaValue) field.get(null));
      }
      if (field.getType().equals(Class.class)) {
        luaTable.set(field.getName(), mapping((Class<?>) field.get(null)));
      }
    }
    return new ReadOnlyLuaTable(luaTable);
  } catch (Exception e) {
    throw new CubesException("Failed to create lua api", e);
  }
}
 
Example #16
Source Project: calcite   Author: apache   File: ScalarFunctionImpl.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Creates {@link org.apache.calcite.schema.ScalarFunction} for each method in
 * a given class.
 */
public static ImmutableMultimap<String, ScalarFunction> createAll(
    Class<?> clazz) {
  final ImmutableMultimap.Builder<String, ScalarFunction> builder =
      ImmutableMultimap.builder();
  for (Method method : clazz.getMethods()) {
    if (method.getDeclaringClass() == Object.class) {
      continue;
    }
    if (!Modifier.isStatic(method.getModifiers())
        && !classHasPublicZeroArgsConstructor(clazz)) {
      continue;
    }
    final ScalarFunction function = create(method);
    builder.put(method.getName(), function);
  }
  return builder.build();
}
 
Example #17
Source Project: jdk8u60   Author: chenghanpeng   File: SwingTest.java    License: GNU General Public License v2.0 6 votes vote down vote up
private void start() throws Throwable {
    do {
        if ((this.method != null) && Modifier.isStatic(this.method.getModifiers())) {
            run(); // invoke static method on the current thread
        }
        else {
            SwingUtilities.invokeLater(this); // invoke on the event dispatch thread
        }
        Toolkit tk = Toolkit.getDefaultToolkit();
        if (tk instanceof SunToolkit) {
            SunToolkit stk = (SunToolkit) tk;
            stk.realSync(); // wait until done
        }
    }
    while (this.frame != null);
    if (this.error != null) {
        throw this.error;
    }
}
 
Example #18
Source Project: clj-graal-docs   Author: lread   File: Reflector2.java    License: Eclipse Public License 1.0 6 votes vote down vote up
public static boolean isAccessibleMatch(Method lhs, Method rhs, Object target) {
        if(!lhs.getName().equals(rhs.getName())
                        || !Modifier.isPublic(lhs.getDeclaringClass().getModifiers())
                        || !canAccess(lhs, target))
        {
                return false;
        }

        Class[] types1 = lhs.getParameterTypes();
        Class[] types2 = rhs.getParameterTypes();
        if(types1.length != types2.length)
                return false;

        boolean match = true;
        for (int i=0; i<types1.length; ++i)
        {
                if(!types1[i].isAssignableFrom(types2[i]))
                {
                        match = false;
                        break;
                }
        }
        return match;
}
 
Example #19
Source Project: pitest-descartes   Author: STAMP-project   File: NewInstanceMutationOperator.java    License: GNU Lesser General Public License v3.0 6 votes vote down vote up
/**
 * Returns a value indicating whether the operator can transform the given method.
 */
@Override
public boolean canMutate(Method method) {
    try {
        Class<?> returnClass = getAppropriateReturnClass(method);

        if(returnClass.equals(String.class)
                || !belongsToJavaPackages(returnClass)
                || Modifier.isAbstract(returnClass.getModifiers())) {
            return false;
        }
        for (Constructor<?> publicConstructor : returnClass.getConstructors()) {
            if (publicConstructor.getParameters().length == 0) {
                return true;
            }
        }
        return false;
    }
    catch (ClassNotFoundException e) {
        return false;
    }
}
 
Example #20
Source Project: jdk1.8-source-analysis   Author: raysonfang   File: ObjectStreamClass.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Returns subclass-accessible no-arg constructor of first non-serializable
 * superclass, or null if none found.  Access checks are disabled on the
 * returned constructor (if any).
 */
private static Constructor<?> getSerializableConstructor(Class<?> cl) {
    Class<?> initCl = cl;
    while (Serializable.class.isAssignableFrom(initCl)) {
        if ((initCl = initCl.getSuperclass()) == null) {
            return null;
        }
    }
    try {
        Constructor<?> cons = initCl.getDeclaredConstructor((Class<?>[]) null);
        int mods = cons.getModifiers();
        if ((mods & Modifier.PRIVATE) != 0 ||
            ((mods & (Modifier.PUBLIC | Modifier.PROTECTED)) == 0 &&
             !packageEquals(cl, initCl)))
        {
            return null;
        }
        cons = reflFactory.newConstructorForSerialization(cl, cons);
        cons.setAccessible(true);
        return cons;
    } catch (NoSuchMethodException ex) {
        return null;
    }
}
 
Example #21
Source Project: astor   Author: SpoonLabs   File: TestReadableDurationConverter.java    License: GNU General Public License v2.0 5 votes vote down vote up
public void testSingleton() throws Exception {
    Class cls = ReadableDurationConverter.class;
    assertEquals(false, Modifier.isPublic(cls.getModifiers()));
    assertEquals(false, Modifier.isProtected(cls.getModifiers()));
    assertEquals(false, Modifier.isPrivate(cls.getModifiers()));
    
    Constructor con = cls.getDeclaredConstructor((Class[]) null);
    assertEquals(1, cls.getDeclaredConstructors().length);
    assertEquals(true, Modifier.isProtected(con.getModifiers()));
    
    Field fld = cls.getDeclaredField("INSTANCE");
    assertEquals(false, Modifier.isPublic(fld.getModifiers()));
    assertEquals(false, Modifier.isProtected(fld.getModifiers()));
    assertEquals(false, Modifier.isPrivate(fld.getModifiers()));
}
 
Example #22
Source Project: xtext-lib   Author: eclipse   File: ToStringBuilder.java    License: Eclipse Public License 2.0 5 votes vote down vote up
@GwtIncompatible("java.lang.reflect.Field")
private ToStringBuilder addField(final Field field) {
	if (!Modifier.isStatic(field.getModifiers())) {
		field.setAccessible(true);
		try {
			add(field.getName(), field.get(instance));
		} catch(IllegalAccessException e) {
			throw Exceptions.sneakyThrow(e);
		}
	}
	return this;
}
 
Example #23
Source Project: groovy   Author: apache   File: MixinInMetaClass.java    License: Apache License 2.0 5 votes vote down vote up
private static CachedConstructor findDefaultConstructor(CachedClass mixinClass) {
    for (CachedConstructor constr : mixinClass.getConstructors()) {
        if (!Modifier.isPublic(constr.getModifiers()))
            continue;

        CachedClass[] classes = constr.getParameterTypes();
        if (classes.length == 0)
            return constr;
    }

    throw new GroovyRuntimeException("No default constructor for class " + mixinClass.getName() + "! Can't be mixed in.");
}
 
Example #24
Source Project: openjdk-jdk8u   Author: AdoptOpenJDK   File: ObjectReader.java    License: GNU General Public License v2.0 5 votes vote down vote up
public void doByte(ByteField field, boolean isVMField) {
   java.lang.reflect.Field f = null;
   try {
      f = readField(field);
      if (Modifier.isFinal(f.getModifiers())) return;
      f.setAccessible(true);
      f.setByte(obj, field.getValue(getObj()));
   } catch (Exception ex) {
      printFieldSetError(f, ex);
   }
}
 
Example #25
Source Project: openjdk-jdk8u-backup   Author: AdoptOpenJDK   File: NashornStaticClassLinker.java    License: GNU General Public License v2.0 5 votes vote down vote up
@Override
public GuardedInvocation getGuardedInvocation(final LinkRequest linkRequest, final LinkerServices linkerServices) throws Exception {
    final LinkRequest request = linkRequest.withoutRuntimeContext(); // Nashorn has no runtime context
    final Object self = request.getReceiver();
    if (self.getClass() != StaticClass.class) {
        return null;
    }
    final Class<?> receiverClass = ((StaticClass) self).getRepresentedClass();

    Bootstrap.checkReflectionAccess(receiverClass, true);
    final CallSiteDescriptor desc = request.getCallSiteDescriptor();
    // We intercept "new" on StaticClass instances to provide additional capabilities
    if ("new".equals(desc.getNameToken(CallSiteDescriptor.OPERATOR))) {
        if (! Modifier.isPublic(receiverClass.getModifiers())) {
            throw ECMAErrors.typeError("new.on.nonpublic.javatype", receiverClass.getName());
        }

        // make sure new is on accessible Class
        Context.checkPackageAccess(receiverClass);

        // Is the class abstract? (This includes interfaces.)
        if (NashornLinker.isAbstractClass(receiverClass)) {
            // Change this link request into a link request on the adapter class.
            final Object[] args = request.getArguments();
            args[0] = JavaAdapterFactory.getAdapterClassFor(new Class<?>[] { receiverClass }, null,
                    linkRequest.getCallSiteDescriptor().getLookup());
            final LinkRequest adapterRequest = request.replaceArguments(request.getCallSiteDescriptor(), args);
            final GuardedInvocation gi = checkNullConstructor(delegate(linkerServices, adapterRequest), receiverClass);
            // Finally, modify the guard to test for the original abstract class.
            return gi.replaceMethods(gi.getInvocation(), Guards.getIdentityGuard(self));
        }
        // If the class was not abstract, just delegate linking to the standard StaticClass linker. Make an
        // additional check to ensure we have a constructor. We could just fall through to the next "return"
        // statement, except we also insert a call to checkNullConstructor() which throws an ECMAScript TypeError
        // with a more intuitive message when no suitable constructor is found.
        return checkNullConstructor(delegate(linkerServices, request), receiverClass);
    }
    // In case this was not a "new" operation, just delegate to the the standard StaticClass linker.
    return delegate(linkerServices, request);
}
 
Example #26
Source Project: jdk8u60   Author: chenghanpeng   File: ObjectReader.java    License: GNU General Public License v2.0 5 votes vote down vote up
public void doChar(CharField field, boolean isVMField) {
   java.lang.reflect.Field f = null;
   try {
      f = readField(field);
      if (Modifier.isFinal(f.getModifiers())) return;
      f.setAccessible(true);
      f.setChar(obj, field.getValue(getObj()));
   } catch (Exception ex) {
      printFieldSetError(f, ex);
   }
}
 
Example #27
Source Project: jdk1.8-source-analysis   Author: raysonfang   File: ObjectStreamClass.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Returns non-static, non-abstract method with given signature provided it
 * is defined by or accessible (via inheritance) by the given class, or
 * null if no match found.  Access checks are disabled on the returned
 * method (if any).
 */
private static Method getInheritableMethod(Class<?> cl, String name,
                                           Class<?>[] argTypes,
                                           Class<?> returnType)
{
    Method meth = null;
    Class<?> defCl = cl;
    while (defCl != null) {
        try {
            meth = defCl.getDeclaredMethod(name, argTypes);
            break;
        } catch (NoSuchMethodException ex) {
            defCl = defCl.getSuperclass();
        }
    }

    if ((meth == null) || (meth.getReturnType() != returnType)) {
        return null;
    }
    meth.setAccessible(true);
    int mods = meth.getModifiers();
    if ((mods & (Modifier.STATIC | Modifier.ABSTRACT)) != 0) {
        return null;
    } else if ((mods & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0) {
        return meth;
    } else if ((mods & Modifier.PRIVATE) != 0) {
        return (cl == defCl) ? meth : null;
    } else {
        return packageEquals(cl, defCl) ? meth : null;
    }
}
 
Example #28
Source Project: es6draft   Author: anba   File: Code.java    License: MIT License 5 votes vote down vote up
public MethodCode newConstructor(int access, MethodTypeDescriptor methodDescriptor, String signature,
        String[] exceptions) {
    if ((access & ~Modifier.constructorModifiers()) != 0) {
        throw new IllegalArgumentException();
    }
    methodCount += 1;
    return new MethodCode(this, access, "<init>", methodDescriptor,
            classWriter.visitMethod(access, "<init>", methodDescriptor.descriptor(), signature, exceptions));
}
 
Example #29
Source Project: coming   Author: SpoonLabs   File: NPEfix_0089_s.java    License: MIT License 5 votes vote down vote up
/**
 * <p>Returns the desired Method much like <code>Class.getMethod</code>, however
 * it ensures that the returned Method is from a public class or interface and not
 * from an anonymous inner class. This means that the Method is invokable and
 * doesn't fall foul of Java bug
 * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957">4071957</a>).
 *
 *  <code><pre>Set set = Collections.unmodifiableSet(...);
 *  Method method = ClassUtils.getPublicMethod(set.getClass(), "isEmpty",  new Class[0]);
 *  Object result = method.invoke(set, new Object[]);</pre></code>
 * </p>
 *
 * @param cls  the class to check, not null
 * @param methodName  the name of the method
 * @param parameterTypes  the list of parameters
 * @return the method
 * @throws NullPointerException if the class is null
 * @throws SecurityException if a a security violation occured
 * @throws NoSuchMethodException if the method is not found in the given class
 *  or if the metothod doen't conform with the requirements
 */
public static Method getPublicMethod(Class<?> cls, String methodName, Class<?> parameterTypes[])
        throws SecurityException, NoSuchMethodException {

    Method declaredMethod = cls.getMethod(methodName, parameterTypes);
    if (Modifier.isPublic(declaredMethod.getDeclaringClass().getModifiers())) {
        return declaredMethod;
    }

    List<Class<?>> candidateClasses = new ArrayList<Class<?>>();
    candidateClasses.addAll(getAllInterfaces(cls));
    candidateClasses.addAll(getAllSuperclasses(cls));

    for (Class<?> candidateClass : candidateClasses) {
        if (!Modifier.isPublic(candidateClass.getModifiers())) {
            continue;
        }
        Method candidateMethod;
        try {
            candidateMethod = candidateClass.getMethod(methodName, parameterTypes);
        } catch (NoSuchMethodException ex) {
            continue;
        }
        if (Modifier.isPublic(candidateMethod.getDeclaringClass().getModifiers())) {
            return candidateMethod;
        }
    }

    throw new NoSuchMethodException("Can't find a public method for " +
            methodName + " " + org.apache.commons.lang3.ArrayUtils.toString(parameterTypes));
}
 
Example #30
Source Project: HotswapAgent   Author: HotswapProjects   File: ClassSignatureBase.java    License: GNU General Public License v2.0 5 votes vote down vote up
private boolean makeAccessible(Method method) {
    if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
            && !method.isAccessible()) {
        method.setAccessible(true);
        return true;
    }
    return false;
}