org.apache.river.reggie.proxy.ClassMapper Maven / Gradle / Ivy

Go to download
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.river.reggie.proxy;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Comparator;
import java.util.WeakHashMap;
import java.lang.ref.SoftReference;
import java.rmi.MarshalException;

/**
 * Maps Class to ServiceType/Base, Class to EntryClass/Base, and Class to
 * Field[], with caching for efficiency.
 *
 * @author Sun Microsystems, Inc.
 *
 */
class ClassMapper {

    /** Weak Map from Class to SoftReference(ServiceTypeBase) */
    private static final WeakHashMap serviceMap = new WeakHashMap(23);
    /** Weak Map from Class to SoftReference(EntryClassBase) */
    private static final WeakHashMap entryMap = new WeakHashMap(17);
    /** Weak Map from Class to SoftReference(sorted Field[]) */
    private static final WeakHashMap fieldMap = new WeakHashMap(17);
    /** Comparator for sorting fields */
    private static final FieldComparator comparator = new FieldComparator();
    private static final ServiceType[] empty = {};
    private static final Class[] noArg = new Class[0];

    private ClassMapper() {}

    /** Returns a ServiceTypeBase descriptor for a class. */
    public static ServiceTypeBase toServiceTypeBase(Class cls) 
        throws MarshalException 
    {
	synchronized (serviceMap) {
	    return toServiceTypeBase(cls, true);
	}
    }

    /**
     * Returns a ServiceTypeBase descriptor for a class.  If needCodebase
     * is false, the returned descriptor's codebase may be null.
     */
    private static ServiceTypeBase toServiceTypeBase(Class cls,
						     boolean needCodebase)
	throws MarshalException 
    {
	if (cls == null)
	    return null;
	SoftReference cref = (SoftReference)serviceMap.get(cls);
	ServiceTypeBase stype = null;
	if (cref != null)
	    stype = (ServiceTypeBase)cref.get();
	if (stype == null) {
	    stype = new ServiceTypeBase(
			   new ServiceType(cls,
					   toServiceType(cls.getSuperclass()),
					   toServiceType(cls.getInterfaces())),
			   null);
	    serviceMap.put(cls, new SoftReference(stype));
	}
	if (needCodebase && stype.codebase == null)
	    stype.setCodebase(cls);
	return stype;
    }

    /** Returns a ServiceType descriptor for a class. */
    private static ServiceType toServiceType(Class cls) 
	throws MarshalException 
    {
	if (cls != null)
	    return toServiceTypeBase(cls, false).type;
	return null;
    }

    /** Converts an array of Class to an array of ServiceType. */
    public static ServiceType[] toServiceType(Class[] classes) 
	throws MarshalException 
    {
	if (classes == null)
	    return null;
	if (classes.length == 0)
	    return empty;
	ServiceType[] stypes = new ServiceType[classes.length];
	synchronized (serviceMap) {
	    for (int i = classes.length; --i >= 0; ) {
		stypes[i] = toServiceType(classes[i]);
	    }
	}
	return stypes;
    }

    /** Returns a EntryClassBase descriptor for a class. */
    public static EntryClassBase toEntryClassBase(Class cls) 
	throws MarshalException 
    {
	synchronized (entryMap) {
	    return toEntryClassBase(cls, true);
	}
    }

    /**
     * Returns a EntryClassBase descriptor for a class.  If base is false,
     * the returned descriptor's codebase may be null, and the class need
     * not be public and need not have a no-arg constructor.
     */
    private static EntryClassBase toEntryClassBase(Class cls, boolean base) 
        throws MarshalException 
    {
	if (cls == null)
	    return null;
	SoftReference cref = (SoftReference)entryMap.get(cls);
	EntryClassBase eclass = null;
	if (cref != null)
	    eclass = (EntryClassBase)cref.get();
	if (eclass == null) {
	    if (base) {
		if (!Modifier.isPublic(cls.getModifiers()))
		    throw new IllegalArgumentException("entry class " +
						       cls.getName() +
						       " is not public");
		try {
		    cls.getConstructor(noArg);
		} catch (NoSuchMethodException e) {
		    throw new IllegalArgumentException("entry class " +
						       cls.getName() +
			        " does not have a public no-arg constructor");
		}
	    }
	    eclass = new EntryClassBase(
			     new EntryClass(cls,
					    toEntryClass(cls.getSuperclass())),
			     null);
	    entryMap.put(cls, new SoftReference(eclass));
	}
	if (base && eclass.codebase == null)
	    eclass.setCodebase(cls);
	return eclass;
    }

    /** Returns an EntryClass descriptor for a class. */
    private static EntryClass toEntryClass(Class cls) throws MarshalException {
	if (cls != null)
	    return toEntryClassBase(cls, false).eclass;
	return null;
    }

    /** Field of an Entry class, with marshalling information */
    static class EntryField {
	/** Field for the field */
	public final Field field;
	/**
	 * True if instances of the field need to be converted
	 * to MarshalledWrapper.  False if the type of the field
	 * is String, Integer, Boolean, Character, Long, Float,
	 * Double, Byte, or Short.
	 */
	public final boolean marshal;

	/**
	 * Basic constructor.
	 */
	public EntryField(Field field) {
	    this.field = field;
	    Class c = field.getType();
	    marshal = !(c == String.class ||
			c == Integer.class ||
			c == Boolean.class ||
			c == Character.class ||
			c == Long.class ||
			c == Float.class ||
			c == Double.class ||
			c == Byte.class ||
			c == Short.class);
	}
    }

    /**
     * Returns public fields, in super to subclass order, sorted
     * alphabetically within a given class.
     */
    public static EntryField[] getFields(Class cls) {
	synchronized (fieldMap) {
	    SoftReference cref = (SoftReference)fieldMap.get(cls);
	    EntryField[] efields = null;
	    if (cref != null)
		efields = (EntryField[])cref.get();
	    if (efields == null) {
		Field[] fields = cls.getFields();
		Arrays.sort(fields, comparator);
		int len = 0;
		for (int i = 0; i < fields.length; i++) {
		    if ((fields[i].getModifiers() &
			 (Modifier.STATIC|Modifier.FINAL|Modifier.TRANSIENT))
			== 0)
		    {
			if (fields[i].getType().isPrimitive())
			    throw new IllegalArgumentException("entry class " +
							       cls.getName() +
						  " has a primitive field");
			fields[len++] = fields[i];
		    }
		}
		efields = new EntryField[len];
		while (--len >= 0) {
		    efields[len] = new EntryField(fields[len]);
		}
		fieldMap.put(cls, new SoftReference(efields));
	    }
	    return efields;
	}
    }

    /** Comparator for sorting fields. */
    private static class FieldComparator implements Comparator {
	public FieldComparator() {}

	/** Super before subclass, alphabetical within a given class */
	public int compare(Object o1, Object o2) {
	    Field f1 = (Field)o1;
	    Field f2 = (Field)o2;
	    if (f1 == f2)
		return 0;
	    if (f1.getDeclaringClass() == f2.getDeclaringClass())
		return f1.getName().compareTo(f2.getName());
	    if (f1.getDeclaringClass().isAssignableFrom(
						     f2.getDeclaringClass()))
		return -1;
	    return 1;
	}
    }
}