Java Code Examples for java.lang.reflect.Modifier#PUBLIC

/**
 * @param methodInfo A map contains args mapped by order or name
 * @see ClassBuilder#addMethod(String, int, Object, Object[], LuaFunction, List, List)
 */
public ClassBuilder addMethod(Map methodInfo) {
    LuaFunction function = mapGet("func", 4, methodInfo);
    Map<?, Object> paramTypes = mapGet("paramTypes", 5, methodInfo);
    Map<?, Map<Object, Object>> annotations = mapGet("annotations", 6, methodInfo);
    Map<?, Map<?, Map<Object, Object>>> paramAnnotations = mapGet("paramAnnotations", 7, methodInfo);
    ArrayList<List<Map<Object,Object>>> paraAnnoList=null;
    if(paramAnnotations!=null){
        paraAnnoList=new ArrayList<>();
        for (Map<?, Map<Object, Object>> annolist:paramAnnotations.values()){
            paraAnnoList.add(new ArrayList<>(annolist.values()));
        }
    }

    Integer flag = mapGet("flag", 2, methodInfo);
    if(flag==null)flag=Modifier.PUBLIC|(function==null?Modifier.ABSTRACT:0);
    return addMethod(mapGet("name", 1, methodInfo), flag,
            mapGet("returnType", 3, methodInfo)
            , paramTypes == null ? null : paramTypes.values().toArray(),
            function, annotations == null ? null : new ArrayList<>(annotations.values())
            , paraAnnoList);
}
 

/**
 * Declares a field.
 *
 * @param flags a bitwise combination of {@link Modifier#PUBLIC}, {@link
 *     Modifier#PRIVATE}, {@link Modifier#PROTECTED}, {@link Modifier#STATIC},
 *     {@link Modifier#FINAL}, {@link Modifier#VOLATILE}, and {@link
 *     Modifier#TRANSIENT}.
 * @param staticValue a constant representing the initial value for the
 *     static field, possibly null. This must be null if this field is
 *     non-static.
 */
public void declare(FieldId<?, ?> fieldId, int flags, Object staticValue) {
    TypeDeclaration typeDeclaration = getTypeDeclaration(fieldId.declaringType);
    if (typeDeclaration.fields.containsKey(fieldId)) {
        throw new IllegalStateException("already declared: " + fieldId);
    }

    int supportedFlags = Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED
            | Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE | Modifier.TRANSIENT
            | AccessFlags.ACC_SYNTHETIC;
    if ((flags & ~supportedFlags) != 0) {
        throw new IllegalArgumentException("Unexpected flag: "
                + Integer.toHexString(flags));
    }

    if ((flags & Modifier.STATIC) == 0 && staticValue != null) {
        throw new IllegalArgumentException("staticValue is non-null, but field is not static");
    }

    FieldDeclaration fieldDeclaration = new FieldDeclaration(fieldId, flags, staticValue);
    typeDeclaration.fields.put(fieldId, fieldDeclaration);
}
 

@Override
public void visitEnd() {
    if (accumulatorType != null) {
        final MethodVisitor getAccumulatorCoder = super.visitMethod(Modifier.PUBLIC, "getAccumulatorCoder",
                "(Lorg/apache/beam/sdk/coders/CoderRegistry;Lorg/apache/beam/sdk/coders/Coder;)"
                        + "Lorg/apache/beam/sdk/coders/Coder;",
                null, null);
        getAccumulatorCoder.visitLdcInsn(accumulatorType);
        getAccumulatorCoder.visitLdcInsn(plugin);
        getAccumulatorCoder
                .visitMethodInsn(INVOKESTATIC,
                        "org/talend/sdk/component/runtime/beam/coder/ContextualSerializableCoder", "of",
                        "(Ljava/lang/Class;Ljava/lang/String;)Lorg/apache/beam/sdk/coders/SerializableCoder;",
                        false);
        getAccumulatorCoder.visitInsn(ARETURN);
        getAccumulatorCoder.visitMaxs(-1, -1);
        getAccumulatorCoder.visitEnd();
    }
    super.visitEnd();
}
 

/**
 * @param type
 * @param name
 * @return Method
 */
public static Method getSetMethod(Class<?> type, String name) {
    Method[] methods = type.getMethods();
    String methodName = "set" + Character.toUpperCase(name.charAt(0)) + name.substring(1);

    for(Method method : methods) {
        if(method.getModifiers() != Modifier.PUBLIC) {
            continue;
        }

        if(method.getName().equals(methodName)) {
            if(method.getParameterTypes().length == 1) {
                return method;
            }
        }
    }
    return null;
}
 

/**
 * ObjectInputStream.resolveProxyClass has some funky way of using 
 * the incorrect class loader to resolve proxy classes, let's do it our way instead
 */
@Override
protected Class<?> resolveProxyClass(String[] interfaces)
        throws IOException, ClassNotFoundException {
    
    ClassLoader latestLoader;
    if (classLoaders != null && classLoaders.length > 0) {
        latestLoader = classLoaders[0];
    } else {
        latestLoader = null;
    }
    ClassLoader nonPublicLoader = null;
    boolean hasNonPublicInterface = false;

    // define proxy in class loader of non-public interface(s), if any
    Class<?>[] classObjs = new Class[interfaces.length];
    for (int i = 0; i < interfaces.length; i++) {
        Class<?> cl = this.resolveClass(interfaces[i]);
        if (latestLoader==null) latestLoader = cl.getClassLoader();
        if ((cl.getModifiers() & Modifier.PUBLIC) == 0) {
            if (hasNonPublicInterface) {
                if (nonPublicLoader != cl.getClassLoader()) {
                    throw new IllegalAccessError(
                            "conflicting non-public interface class loaders");
                }
            } else {
                nonPublicLoader = cl.getClassLoader();
                hasNonPublicInterface = true;
            }
        }
        classObjs[i] = cl;
    }
    try {
        return Proxy.getProxyClass(hasNonPublicInterface ? nonPublicLoader
                : latestLoader, classObjs);
    } catch (IllegalArgumentException e) {
        throw new ClassNotFoundException(null, e);
    }
}
 

/**
 * Returns public no-arg constructor of given class, or null if none found.
 * Access checks are disabled on the returned constructor (if any), since
 * the defining class may still be non-public.
 */
private static Constructor<?> getExternalizableConstructor(Class<?> cl) {
    try {
        Constructor<?> cons = cl.getDeclaredConstructor((Class<?>[]) null);
        cons.setAccessible(true);
        return ((cons.getModifiers() & Modifier.PUBLIC) != 0) ?
            cons : null;
    } catch (NoSuchMethodException ex) {
        return null;
    }
}
 

static String getVKText(int keyCode) {
    VKCollection vkCollect = getVKCollection();
    Integer key = Integer.valueOf(keyCode);
    String name = vkCollect.findName(key);
    if (name != null) {
        return name.substring(3);
    }
    int expected_modifiers =
        (Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL);

    Field[] fields = KeyEvent.class.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
        try {
            if (fields[i].getModifiers() == expected_modifiers
                && fields[i].getType() == Integer.TYPE
                && fields[i].getName().startsWith("VK_")
                && fields[i].getInt(KeyEvent.class) == keyCode)
            {
                name = fields[i].getName();
                vkCollect.put(name, key);
                return name.substring(3);
            }
        } catch (IllegalAccessException e) {
            assert(false);
        }
    }
    return "UNKNOWN";
}
 

private MethodMetadata getHashCodeMethod() {
    // Define method parameter types
    List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(
            0);

    // Check if a method exist in type
    final MethodMetadata method = helper.methodExists(TO_STRING_METHOD,
            parameterTypes);
    if (method != null) {
        // If it already exists, just return the method
        return method;
    }

    // Define method annotations (none in this case)
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();

    // Define method throws types (none in this case)
    List<JavaType> throwsTypes = new ArrayList<JavaType>();

    // Define method parameter names (none in this case)
    List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(0);

    // Create the method body
    InvocableMemberBodyBuilder body = new InvocableMemberBodyBuilder();
    body.appendFormalLine(String.format(
            "return new %s(17, 31).append(%s).append(%s).toHashCode();",
            helper.getFinalTypeName(HASH_CODE_BUILDER), ID_FIELD,
            TIMESTAMP_FIELD));

    // Use the MethodMetadataBuilder for easy creation of MethodMetadata
    MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(
            context.getMetadataId(), Modifier.PUBLIC, HASH_CODE_METHOD,
            JavaType.INT_PRIMITIVE, parameterTypes, parameterNames, body);
    methodBuilder.setAnnotations(annotations);
    methodBuilder.setThrowsTypes(throwsTypes);

    return methodBuilder.build(); // Build and return a MethodMetadata
}
 

public int getVisibility( )
{
	if ( field == null )
		return VISIBILITY_PUBLIC;

	if ( ( field.getModifiers( ) & Modifier.STATIC ) != 0 )
	{
		return VISIBILITY_STATIC;
	}
	else if ( ( field.getModifiers( ) & Modifier.PUBLIC ) != 0 )
	{
		return VISIBILITY_PUBLIC;
	}
	else if ( ( field.getModifiers( ) & Modifier.PRIVATE ) != 0 )
	{
		return VISIBILITY_PRIVATE;

	}
	else if ( ( field.getModifiers( ) & Modifier.PROTECTED ) != 0 )
	{
		return VISIBILITY_PROTECTED;
	}
	else
	{
		return VISIBILITY_PUBLIC;
	}
}
 

static String getVKText(int keyCode) {
    VKCollection vkCollect = getVKCollection();
    Integer key = Integer.valueOf(keyCode);
    String name = vkCollect.findName(key);
    if (name != null) {
        return name.substring(3);
    }
    int expected_modifiers =
        (Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL);

    Field[] fields = KeyEvent.class.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
        try {
            if (fields[i].getModifiers() == expected_modifiers
                && fields[i].getType() == Integer.TYPE
                && fields[i].getName().startsWith("VK_")
                && fields[i].getInt(KeyEvent.class) == keyCode)
            {
                name = fields[i].getName();
                vkCollect.put(name, key);
                return name.substring(3);
            }
        } catch (IllegalAccessException e) {
            assert(false);
        }
    }
    return "UNKNOWN";
}
 

private static Method getPublicMethod(Class<?> clazz, String methodName, Class[] parameterTypes) {
  Method method = null;
  try {
    method = clazz.getMethod(methodName, parameterTypes);
    if ((method.getModifiers() & Modifier.PUBLIC) == 0) {
      method = null;
    }
  } catch (NoSuchMethodException e) {
    // None.
  }
  return method;
}
 

private static Object createObjectProxy(Object realObject, Class realClass, ObjectProxyMethodHook hook) throws Throwable {
	ClassPool pool = ClassPool.getDefault();
	CtClass cc = pool.makeClass(HackJavaFX.class.getPackage().getName() + "." +
			realClass.getSimpleName() + "_Proxy");
	cc.setSuperclass(pool.get(realClass.getName()));
	CtField realObjectField = new CtField(cc.getSuperclass(), "realObject", cc);
	realObjectField.setModifiers(Modifier.FINAL | Modifier.PRIVATE);
	cc.addField(realObjectField);
	CtField realClassField = new CtField(pool.get("java.lang.Class"), "realClass", cc);
	realClassField.setModifiers(Modifier.FINAL | Modifier.PRIVATE);
	cc.addField(realClassField);
	CtConstructor constructor = new CtConstructor(
			new CtClass[]{realObjectField.getType(), realClassField.getType()}, cc
	);
	constructor.setModifiers(Modifier.PUBLIC);
	constructor.setBody("{ realObject = $1; realClass = $2; }");
	cc.addConstructor(constructor);
	for (CtMethod method : cc.getSuperclass().getDeclaredMethods()) {
		if ((method.getModifiers() & Modifier.FINAL) != 0) {
			continue;
		}
		if ((method.getModifiers() & Modifier.STATIC) != 0) {
			continue;
		}
		CtMethod newMethod = new CtMethod(method.getReturnType(), method.getName(),
				method.getParameterTypes(), cc);
		newMethod.setModifiers(method.getModifiers() & ~(Modifier.NATIVE | Modifier.SYNCHRONIZED));
		newMethod.setExceptionTypes(method.getExceptionTypes());
		if (newMethod.getReturnType().equals(CtClass.voidType)) {
			if ((newMethod.getModifiers() & Modifier.PUBLIC) != 0) {
				newMethod.setBody("realObject." + method.getName() + "($$);");
			} else {
				newMethod.setBody("{ java.lang.reflect.Method method = realClass.getDeclaredMethod(\""
						+ method.getName() + "\", $sig);" + "method.setAccessible(true);"
						+ "method.invoke(this.realObject, $args); }");
			}
		} else {
			if ((newMethod.getModifiers() & Modifier.PUBLIC) != 0) {
				newMethod.setBody("return realObject." + method.getName() + "($$);");
			} else {
				newMethod.setBody("{ java.lang.reflect.Method method = realClass.getDeclaredMethod(\""
						+ method.getName() + "\", $sig);" + "method.setAccessible(true);"
						+ "java.lang.Object retVal = method.invoke(realObject, $args);"
						+ "return ($r) retVal; }");
			}
		}
		if (hook != null) {
			hook.processMethod(newMethod);
		}
		cc.addMethod(newMethod);
	}
	Class cls = cc.toClass();
	Constructor c = cls.getDeclaredConstructor(cls.getSuperclass(), Class.class);
	Object proxy = c.newInstance(realObject, realClass);
	for (Field field : realClass.getDeclaredFields()) {
		if ((field.getModifiers() & Modifier.STATIC) != 0) {
			continue;
		}
		if ((field.getModifiers() & Modifier.FINAL) != 0) {
			continue;
		}
		field.setAccessible(true);
		field.set(proxy, field.get(realObject));
	}
	return proxy;
}
 

/**
 * Create the class for entity which will hold the revision information for
 * Hibernate Envers
 * <p/>
 * This use {@link #REVISION_LOG_ENTITY_NAME} as class name and look for
 * <em>the first package which contains a entity</em> to place it.
 * 
 */
public void installRevisonEntity(JavaType revisionEntity) {

    PathResolver pathResolver = projectOperations.getPathResolver();

    JavaType target;
    if (revisionEntity == null) {
        target = generateRevionEntityJavaType();
    }
    else {
        target = revisionEntity;
    }

    int modifier = Modifier.PUBLIC;

    final String declaredByMetadataId = PhysicalTypeIdentifier
            .createIdentifier(target,
                    pathResolver.getFocusedPath(Path.SRC_MAIN_JAVA));
    File targetFile = new File(
            typeLocationService
                    .getPhysicalTypeCanonicalPath(declaredByMetadataId));
    if (targetFile.exists()) {
        Validate.isTrue(!targetFile.exists(), "Type '%s' already exists",
                target);
    }

    // Prepare class builder
    final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
            declaredByMetadataId, modifier, target,
            PhysicalTypeCategory.CLASS);

    // Prepare annotations array
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>(
            1);

    // Add @GvNIXJpaAuditListener annotation
    AnnotationMetadataBuilder jpaAuditRevEntAnn = new AnnotationMetadataBuilder(
            new JavaType(GvNIXJpaAuditRevisionEntity.class));
    annotations.add(jpaAuditRevEntAnn);

    // Set annotations
    cidBuilder.setAnnotations(annotations);

    // Create Revision entity class
    typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());
}
 

public static void ensureMemberAccess(Class<?> currentClass,
                                      Class<?> memberClass,
                                      Object target,
                                      int modifiers)
    throws IllegalAccessException
{
    if (target == null && Modifier.isProtected(modifiers)) {
        int mods = modifiers;
        mods = mods & (~Modifier.PROTECTED);
        mods = mods | Modifier.PUBLIC;

        /*
         * See if we fail because of class modifiers
         */
        Reflection.ensureMemberAccess(currentClass,
                                      memberClass,
                                      target,
                                      mods);
        try {
            /*
             * We're still here so class access was ok.
             * Now try with default field access.
             */
            mods = mods & (~Modifier.PUBLIC);
            Reflection.ensureMemberAccess(currentClass,
                                          memberClass,
                                          target,
                                          mods);
            /*
             * We're still here so access is ok without
             * checking for protected.
             */
            return;
        } catch (IllegalAccessException e) {
            /*
             * Access failed but we're 'protected' so
             * if the test below succeeds then we're ok.
             */
            if (isSubclassOf(currentClass, memberClass)) {
                return;
            } else {
                throw e;
            }
        }
    } else {
        Reflection.ensureMemberAccess(currentClass,
                                      memberClass,
                                      target,
                                      modifiers);
    }
}
 

private MethodMetadata getRevisionDate() {
    if (revsionDateGetter == null) {
        JavaSymbolName methodName = helper
                .getGetterMethodNameForField(REVISION_DATE_TRANSIENT_FIELD);
        // Define method parameter types
        List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(
                0);

        // Check if a method exist in type
        final MethodMetadata method = helper.methodExists(methodName,
                parameterTypes);
        if (method != null) {
            // If it already exists, just return the method
            return method;
        }

        // Define method annotations (none in this case)
        List<AnnotationMetadataBuilder> annotations = helper
                .toAnnotationMetadata(JpaJavaType.TRANSIENT);

        // Define method throws types (none in this case)
        List<JavaType> throwsTypes = new ArrayList<JavaType>();

        // Define method parameter names (none in this case)
        List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(
                0);

        // Create the method body
        InvocableMemberBodyBuilder body = new InvocableMemberBodyBuilder();
        // return new Date(this.timestamp);
        body.appendFormalLine(String.format("return new %s(this.%s);",
                helper.getFinalTypeName(JdkJavaType.DATE), TIMESTAMP_FIELD));

        // Use the MethodMetadataBuilder for easy creation of MethodMetadata
        MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(
                context.getMetadataId(), Modifier.PUBLIC, methodName,
                JdkJavaType.DATE, parameterTypes, parameterNames, body);
        methodBuilder.setAnnotations(annotations);
        methodBuilder.setThrowsTypes(throwsTypes);

        revsionDateGetter = methodBuilder.build(); // Build and return a
                                                   // MethodMetadata

    }
    return revsionDateGetter;
}
 

/**
 * Add to the aspect the MethodMetadata of the generateReportForm method. It
 * uses AbstractMetadataItem.builder for add the new method.
 * 
 * @param reportName
 * @param entity
 * @param reportMethods2
 * @return
 */
private MethodMetadata addGenerateReportFormMethod(JavaType entity,
        String reportName, String reportFormats) {
    // Specify the desired method name
    JavaSymbolName methodName = new JavaSymbolName(generateMethodName(
            reportName, true));

    // Define method parameter types
    List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>();
    parameterTypes.add(new AnnotatedJavaType(MODEL_TYPE,
            new ArrayList<AnnotationMetadata>()));

    // Check if a method with the same signature already exists in the
    // target type
    MethodMetadata reportMethod = reportMethodExists(methodName);
    if (reportMethod != null) {
        // If it already exists, just return the method and omit its
        // generation via the ITD
        return reportMethod;
    }

    // Define method parameter names
    List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>();
    parameterNames.add(new JavaSymbolName("uiModel"));

    // Define method annotations
    List<AnnotationAttributeValue<?>> requestMappingAttributes = new ArrayList<AnnotationAttributeValue<?>>();
    requestMappingAttributes.add(new StringAttributeValue(
            VALUE_SYMBOL_NAME, "/reports/".concat(reportName)));
    requestMappingAttributes.add(new StringAttributeValue(
            PARAMS_SYMBOL_NAME, "form"));
    requestMappingAttributes
            .add(new EnumAttributeValue(METHOD_SYMBOL_NAME,
                    new EnumDetails(REQUEST_METHOD_TYPE,
                            new JavaSymbolName("GET"))));
    AnnotationMetadataBuilder requestMapping = new AnnotationMetadataBuilder(
            REQUEST_MAPPING_TYPE, requestMappingAttributes);
    List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();
    annotations.add(requestMapping);

    // Create the method body
    InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();

    // Populate report_formats list for select
    String reportFormatsAsArray = getReportFormatsAsArray(reportFormats);
    bodyBuilder.appendFormalLine("String[] reportFormats =  ".concat(
            reportFormatsAsArray).concat(";"));
    bodyBuilder
            .appendFormalLine("Collection<String> reportFormatsList = Arrays.asList(reportFormats);");
    bodyBuilder
            .appendFormalLine("uiModel.addAttribute(\"report_formats\", reportFormatsList);");

    // return the View
    bodyBuilder.appendFormalLine("return \""
            .concat(annotationValues.getPath()).concat("/")
            .concat(reportName).concat("\";"));

    // ImportRegistrationResolver gives access to imports in the
    // Java/AspectJ source
    ImportRegistrationResolver irr = builder
            .getImportRegistrationResolver();
    irr.addImport(new JavaType("java.util.Arrays"));
    irr.addImport(new JavaType("java.util.Collection"));

    // Use the MethodMetadataBuilder for easy creation of MethodMetadata
    MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(
            getId(), Modifier.PUBLIC, methodName, JavaType.STRING,
            parameterTypes, parameterNames, bodyBuilder);
    methodBuilder.setAnnotations(annotations);

    reportMethod = methodBuilder.build();
    builder.addMethod(reportMethod);
    controllerMethods.add(reportMethod);
    return reportMethod;
}
 

/**
 * Returns a proxy class that implements the interfaces named in a proxy
 * class descriptor; subclasses may implement this method to read custom
 * data from the stream along with the descriptors for dynamic proxy
 * classes, allowing them to use an alternate loading mechanism for the
 * interfaces and the proxy class.
 *
 * <p>This method is called exactly once for each unique proxy class
 * descriptor in the stream.
 *
 * <p>The corresponding method in <code>ObjectOutputStream</code> is
 * <code>annotateProxyClass</code>.  For a given subclass of
 * <code>ObjectInputStream</code> that overrides this method, the
 * <code>annotateProxyClass</code> method in the corresponding subclass of
 * <code>ObjectOutputStream</code> must write any data or objects read by
 * this method.
 *
 * <p>The default implementation of this method in
 * <code>ObjectInputStream</code> returns the result of calling
 * <code>Proxy.getProxyClass</code> with the list of <code>Class</code>
 * objects for the interfaces that are named in the <code>interfaces</code>
 * parameter.  The <code>Class</code> object for each interface name
 * <code>i</code> is the value returned by calling
 * <pre>
 *     Class.forName(i, false, loader)
 * </pre>
 * where <code>loader</code> is that of the first non-<code>null</code>
 * class loader up the execution stack, or <code>null</code> if no
 * non-<code>null</code> class loaders are on the stack (the same class
 * loader choice used by the <code>resolveClass</code> method).  Unless any
 * of the resolved interfaces are non-public, this same value of
 * <code>loader</code> is also the class loader passed to
 * <code>Proxy.getProxyClass</code>; if non-public interfaces are present,
 * their class loader is passed instead (if more than one non-public
 * interface class loader is encountered, an
 * <code>IllegalAccessError</code> is thrown).
 * If <code>Proxy.getProxyClass</code> throws an
 * <code>IllegalArgumentException</code>, <code>resolveProxyClass</code>
 * will throw a <code>ClassNotFoundException</code> containing the
 * <code>IllegalArgumentException</code>.
 *
 * @param interfaces the list of interface names that were
 *                deserialized in the proxy class descriptor
 * @return  a proxy class for the specified interfaces
 * @throws        IOException any exception thrown by the underlying
 *                <code>InputStream</code>
 * @throws        ClassNotFoundException if the proxy class or any of the
 *                named interfaces could not be found
 * @see ObjectOutputStream#annotateProxyClass(Class)
 * @since 1.3
 */
protected Class<?> resolveProxyClass(String[] interfaces)
    throws IOException, ClassNotFoundException
{
    ClassLoader latestLoader = latestUserDefinedLoader();
    ClassLoader nonPublicLoader = null;
    boolean hasNonPublicInterface = false;

    // define proxy in class loader of non-public interface(s), if any
    Class<?>[] classObjs = new Class<?>[interfaces.length];
    for (int i = 0; i < interfaces.length; i++) {
        Class<?> cl = Class.forName(interfaces[i], false, latestLoader);
        if ((cl.getModifiers() & Modifier.PUBLIC) == 0) {
            if (hasNonPublicInterface) {
                if (nonPublicLoader != cl.getClassLoader()) {
                    throw new IllegalAccessError(
                        "conflicting non-public interface class loaders");
                }
            } else {
                nonPublicLoader = cl.getClassLoader();
                hasNonPublicInterface = true;
            }
        }
        classObjs[i] = cl;
    }
    try {
        return Proxy.getProxyClass(
            hasNonPublicInterface ? nonPublicLoader : latestLoader,
            classObjs);
    } catch (IllegalArgumentException e) {
        throw new ClassNotFoundException(null, e);
    }
}
 

/**
 * Returns a proxy class that implements the interfaces named in a proxy
 * class descriptor; subclasses may implement this method to read custom
 * data from the stream along with the descriptors for dynamic proxy
 * classes, allowing them to use an alternate loading mechanism for the
 * interfaces and the proxy class.
 *
 * <p>This method is called exactly once for each unique proxy class
 * descriptor in the stream.
 *
 * <p>The corresponding method in <code>ObjectOutputStream</code> is
 * <code>annotateProxyClass</code>.  For a given subclass of
 * <code>ObjectInputStream</code> that overrides this method, the
 * <code>annotateProxyClass</code> method in the corresponding subclass of
 * <code>ObjectOutputStream</code> must write any data or objects read by
 * this method.
 *
 * <p>The default implementation of this method in
 * <code>ObjectInputStream</code> returns the result of calling
 * <code>Proxy.getProxyClass</code> with the list of <code>Class</code>
 * objects for the interfaces that are named in the <code>interfaces</code>
 * parameter.  The <code>Class</code> object for each interface name
 * <code>i</code> is the value returned by calling
 * <pre>
 *     Class.forName(i, false, loader)
 * </pre>
 * where <code>loader</code> is that of the first non-<code>null</code>
 * class loader up the execution stack, or <code>null</code> if no
 * non-<code>null</code> class loaders are on the stack (the same class
 * loader choice used by the <code>resolveClass</code> method).  Unless any
 * of the resolved interfaces are non-public, this same value of
 * <code>loader</code> is also the class loader passed to
 * <code>Proxy.getProxyClass</code>; if non-public interfaces are present,
 * their class loader is passed instead (if more than one non-public
 * interface class loader is encountered, an
 * <code>IllegalAccessError</code> is thrown).
 * If <code>Proxy.getProxyClass</code> throws an
 * <code>IllegalArgumentException</code>, <code>resolveProxyClass</code>
 * will throw a <code>ClassNotFoundException</code> containing the
 * <code>IllegalArgumentException</code>.
 *
 * @param interfaces the list of interface names that were
 *                deserialized in the proxy class descriptor
 * @return  a proxy class for the specified interfaces
 * @throws        IOException any exception thrown by the underlying
 *                <code>InputStream</code>
 * @throws        ClassNotFoundException if the proxy class or any of the
 *                named interfaces could not be found
 * @see ObjectOutputStream#annotateProxyClass(Class)
 * @since 1.3
 */
protected Class<?> resolveProxyClass(String[] interfaces)
    throws IOException, ClassNotFoundException
{
    ClassLoader latestLoader = latestUserDefinedLoader();
    ClassLoader nonPublicLoader = null;
    boolean hasNonPublicInterface = false;

    // define proxy in class loader of non-public interface(s), if any
    Class<?>[] classObjs = new Class<?>[interfaces.length];
    for (int i = 0; i < interfaces.length; i++) {
        Class<?> cl = Class.forName(interfaces[i], false, latestLoader);
        if ((cl.getModifiers() & Modifier.PUBLIC) == 0) {
            if (hasNonPublicInterface) {
                if (nonPublicLoader != cl.getClassLoader()) {
                    throw new IllegalAccessError(
                        "conflicting non-public interface class loaders");
                }
            } else {
                nonPublicLoader = cl.getClassLoader();
                hasNonPublicInterface = true;
            }
        }
        classObjs[i] = cl;
    }
    try {
        return Proxy.getProxyClass(
            hasNonPublicInterface ? nonPublicLoader : latestLoader,
            classObjs);
    } catch (IllegalArgumentException e) {
        throw new ClassNotFoundException(null, e);
    }
}
 

/**
 * Returns a proxy class that implements the interfaces named in a proxy
 * class descriptor; subclasses may implement this method to read custom
 * data from the stream along with the descriptors for dynamic proxy
 * classes, allowing them to use an alternate loading mechanism for the
 * interfaces and the proxy class.
 *
 * <p>This method is called exactly once for each unique proxy class
 * descriptor in the stream.
 *
 * <p>The corresponding method in <code>ObjectOutputStream</code> is
 * <code>annotateProxyClass</code>.  For a given subclass of
 * <code>ObjectInputStream</code> that overrides this method, the
 * <code>annotateProxyClass</code> method in the corresponding subclass of
 * <code>ObjectOutputStream</code> must write any data or objects read by
 * this method.
 *
 * <p>The default implementation of this method in
 * <code>ObjectInputStream</code> returns the result of calling
 * <code>Proxy.getProxyClass</code> with the list of <code>Class</code>
 * objects for the interfaces that are named in the <code>interfaces</code>
 * parameter.  The <code>Class</code> object for each interface name
 * <code>i</code> is the value returned by calling
 * <pre>
 *     Class.forName(i, false, loader)
 * </pre>
 * where <code>loader</code> is that of the first non-<code>null</code>
 * class loader up the execution stack, or <code>null</code> if no
 * non-<code>null</code> class loaders are on the stack (the same class
 * loader choice used by the <code>resolveClass</code> method).  Unless any
 * of the resolved interfaces are non-public, this same value of
 * <code>loader</code> is also the class loader passed to
 * <code>Proxy.getProxyClass</code>; if non-public interfaces are present,
 * their class loader is passed instead (if more than one non-public
 * interface class loader is encountered, an
 * <code>IllegalAccessError</code> is thrown).
 * If <code>Proxy.getProxyClass</code> throws an
 * <code>IllegalArgumentException</code>, <code>resolveProxyClass</code>
 * will throw a <code>ClassNotFoundException</code> containing the
 * <code>IllegalArgumentException</code>.
 *
 * @param interfaces the list of interface names that were
 *                deserialized in the proxy class descriptor
 * @return  a proxy class for the specified interfaces
 * @throws        IOException any exception thrown by the underlying
 *                <code>InputStream</code>
 * @throws        ClassNotFoundException if the proxy class or any of the
 *                named interfaces could not be found
 * @see ObjectOutputStream#annotateProxyClass(Class)
 * @since 1.3
 */
protected Class<?> resolveProxyClass(String[] interfaces)
    throws IOException, ClassNotFoundException
{
    ClassLoader latestLoader = latestUserDefinedLoader();
    ClassLoader nonPublicLoader = null;
    boolean hasNonPublicInterface = false;

    // define proxy in class loader of non-public interface(s), if any
    Class<?>[] classObjs = new Class<?>[interfaces.length];
    for (int i = 0; i < interfaces.length; i++) {
        Class<?> cl = Class.forName(interfaces[i], false, latestLoader);
        if ((cl.getModifiers() & Modifier.PUBLIC) == 0) {
            if (hasNonPublicInterface) {
                if (nonPublicLoader != cl.getClassLoader()) {
                    throw new IllegalAccessError(
                        "conflicting non-public interface class loaders");
                }
            } else {
                nonPublicLoader = cl.getClassLoader();
                hasNonPublicInterface = true;
            }
        }
        classObjs[i] = cl;
    }
    try {
        return Proxy.getProxyClass(
            hasNonPublicInterface ? nonPublicLoader : latestLoader,
            classObjs);
    } catch (IllegalArgumentException e) {
        throw new ClassNotFoundException(null, e);
    }
}
 

/**
 * Checks the compatibility between two modifier masks. Checks that they are equal
 * with regards to access and static modifier.
 *
 * @return true if the modifiers are compatible
 */
private static boolean compatibleModifiers(int modifiersA, int modifiersB) {
    int mask = Modifier.PRIVATE | Modifier.PROTECTED | Modifier.PUBLIC | Modifier.STATIC;
    return (modifiersA & mask) == (modifiersB & mask);
}