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

The following examples show how to use java.lang.reflect.Modifier#PUBLIC . 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 File: ClassBuilder.java    From lua-for-android with BSD 3-Clause "New" or "Revised" License 6 votes vote down vote up
/**
 * @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);
}
 
Example 2
Source File: DexMaker.java    From dexmaker with Apache License 2.0 6 votes vote down vote up
/**
 * 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);
}
 
Example 3
Source File: BeamIOTransformer.java    From component-runtime with Apache License 2.0 6 votes vote down vote up
@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();
}
 
Example 4
Source File: ClassUtil.java    From nh-micro with Apache License 2.0 6 votes vote down vote up
/**
 * @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;
}
 
Example 5
Source File: ReplicationStream.java    From Tomcat7.0.67 with Apache License 2.0 5 votes vote down vote up
/**
 * 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);
    }
}
 
Example 6
Source File: ObjectStreamClass.java    From dragonwell8_jdk with GNU General Public License v2.0 5 votes vote down vote up
/**
 * 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;
    }
}
 
Example 7
Source File: AWTKeyStroke.java    From openjdk-jdk8u with GNU General Public License v2.0 5 votes vote down vote up
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";
}
 
Example 8
Source File: EnversRevisionLogEntityMetadataBuilder.java    From gvnix with GNU General Public License v3.0 5 votes vote down vote up
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
}
 
Example 9
Source File: JavaClassJSObject.java    From birt with Eclipse Public License 1.0 5 votes vote down vote up
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;
	}
}
 
Example 10
Source File: AWTKeyStroke.java    From jdk8u60 with GNU General Public License v2.0 5 votes vote down vote up
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";
}
 
Example 11
Source File: OptionalMethod.java    From styT with Apache License 2.0 5 votes vote down vote up
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;
}
 
Example 12
Source File: HackJavaFX.java    From DeskChan with GNU Lesser General Public License v3.0 4 votes vote down vote up
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;
}
 
Example 13
Source File: JpaAuditOperationsImpl.java    From gvnix with GNU General Public License v3.0 4 votes vote down vote up
/**
 * 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());
}
 
Example 14
Source File: ReflectUtil.java    From jdk8u-jdk with GNU General Public License v2.0 4 votes vote down vote up
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);
    }
}
 
Example 15
Source File: EnversRevisionLogEntityMetadataBuilder.java    From gvnix with GNU General Public License v3.0 4 votes vote down vote up
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;
}
 
Example 16
Source File: ReportMetadata.java    From gvnix with GNU General Public License v3.0 4 votes vote down vote up
/**
 * 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;
}
 
Example 17
Source File: ObjectInputStream.java    From hottub with GNU General Public License v2.0 3 votes vote down vote up
/**
 * 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);
    }
}
 
Example 18
Source File: ObjectInputStream.java    From openjdk-8-source with GNU General Public License v2.0 3 votes vote down vote up
/**
 * 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);
    }
}
 
Example 19
Source File: ObjectInputStream.java    From Java8CN with Apache License 2.0 3 votes vote down vote up
/**
 * 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);
    }
}
 
Example 20
Source File: MetaMethod.java    From groovy with Apache License 2.0 2 votes vote down vote up
/**
 * 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);
}