org.openrdf.repository.object.composition.AbstractClassFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of alibaba-composition-object Show documentation
The Object Composition library merges multiple Java objects into a single multi-subject object.
The newest version!
/*
 * Copyright (c) 2009-2010, James Leigh and Zepheira LLC Some rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution. 
 * - Neither the name of the openrdf.org nor the names of its contributors may
 *   be used to endorse or promote products derived from this software without
 *   specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 */
package org.openrdf.repository.object.composition;

import static java.lang.reflect.Modifier.isAbstract;
import static java.lang.reflect.Modifier.isFinal;
import static java.lang.reflect.Modifier.isProtected;
import static org.openrdf.repository.object.traits.RDFObjectBehaviour.GET_ENTITY_METHOD;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.openrdf.repository.object.composition.helpers.BehaviourConstructor;
import org.openrdf.repository.object.exceptions.ObjectCompositionException;
import org.openrdf.repository.object.managers.PropertyMapper;
import org.openrdf.repository.object.traits.RDFObjectBehaviour;

/**
 * Creates subclasses of abstract behaviours that can be instaniated.
 * 
 * @author James Leigh
 * 
 */
public class AbstractClassFactory implements BehaviourProvider {

	private static final String BEAN_FIELD_NAME = "_$bean";
	private static final String CLASS_PREFIX = "object.behaviours.";
	private ClassFactory cp;
	private Set> bases;

	public void setClassDefiner(ClassFactory definer) {
		this.cp = definer;
	}

	public void setBaseClasses(Set> bases) {
		this.bases = bases;
	}

	public void setPropertyMapper(PropertyMapper mapper) {
		// don't need it
	}

	public Collection getBehaviourFactories(
		Collection> classes) throws ObjectCompositionException {
		Set> faces = new HashSet>();
		for (Class i : classes) {
			faces.add(i);
			faces = getImplementingClasses(i, faces);
		}
		List result = new ArrayList(faces.size());
		for (Class concept : faces) {
			result.addAll(getBehaviourFactories(concept));
		}
		return result;
	}

	private Collection getBehaviourFactories(Class concept) throws ObjectCompositionException {
		try {
			List result = new ArrayList();
			if (isEnhanceable(concept)) {
				for (Class mapper : findImplementations(concept)) {
					result.add(new BehaviourConstructor(mapper));
				}
			}
			return result;
		} catch (ObjectCompositionException e) {
			throw e;
		} catch (Exception e) {
			throw new ObjectCompositionException(e);
		}
	}

	private Collection> findImplementations(
			Class concept) throws Exception {
		return Collections.singleton(findBehaviour(concept));
	}

	private boolean isBaseClass(Class role) {
		return bases != null && bases.contains(role);
	}

	private final Class findBehaviour(Class concept) throws Exception {
		String className = getJavaClassName(concept);
		synchronized (cp) {
			try {
				return cp.classForName(className);
			} catch (ClassNotFoundException e2) {
				return implement(className, concept);
			}
		}
	}

	private ClassTemplate createBehaviourTemplate(String className,
			Class concept) {
		ClassTemplate cc = createClassTemplate(className, concept);
		cc.addInterface(RDFObjectBehaviour.class);
		addNewConstructor(cc, concept);
		addRDFObjectBehaviourMethod(cc);
		return cc;
	}

	private boolean isOverridden(Method m) {
		if (m.getParameterTypes().length > 0)
			return false;
		if (RDFObjectBehaviour.GET_ENTITY_METHOD.equals(m.getName()))
			return true;
		return false;
	}

	private String getJavaClassName(Class concept) {
		String suffix = getClass().getSimpleName().replaceAll("Factory$", "");
		return CLASS_PREFIX + concept.getName() + suffix;
	}

	private Class implement(String className, Class concept)
			throws Exception {
		ClassTemplate cc = createBehaviourTemplate(className, concept);
		enhance(cc, concept);
		return cp.createClass(cc);
	}

	private void addNewConstructor(ClassTemplate cc, Class concept) {
		if (!concept.isInterface()) {
			try {
				concept.getConstructor(); // must have a default constructor
			} catch (NoSuchMethodException e) {
				throw new ObjectCompositionException(concept.getSimpleName()
						+ " must have a default constructor");
			}
		}
		cc.createField(Object.class, BEAN_FIELD_NAME);
		cc.addConstructor(new Class[] { Object.class },
				BEAN_FIELD_NAME + " = $1;");
	}

	private void addRDFObjectBehaviourMethod(ClassTemplate cc) {
		cc.createMethod(Object.class,
				RDFObjectBehaviour.GET_ENTITY_METHOD).code("return ").code(
				BEAN_FIELD_NAME).code(";").end();
	}

	private Set> getImplementingClasses(Class role,
			Set> implementations) {
		// don't consider interfaces or super classes
		return implementations;
	}

	private ClassTemplate createClassTemplate(String className, Class role) {
		ClassTemplate cc = cp.createClassTemplate(className, role);
		cc.copyAnnotationsFrom(role);
		return cc;
	}

	private boolean isEnhanceable(Class role) {
		return !role.isInterface() && isAbstract(role.getModifiers())
				&& !isBaseClass(role);
	}

	private void enhance(ClassTemplate cc, Class c) throws Exception {
		if (Object.class.equals(c.getMethod("toString").getDeclaringClass())) {
			overrideToStringMethod(cc);
		}
		if (Object.class.equals(c.getMethod("equals", Object.class)
				.getDeclaringClass())
				&& Object.class.equals(c.getMethod("hashCode")
						.getDeclaringClass())) {
			overrideEqualsMethod(cc);
		}
		for (Method m : getMethods(c)) {
			if (isFinal(m.getModifiers()))
				continue;
			if (!isAbstract(m.getModifiers()))
				continue;
			if (isOverridden(m))
				continue;
			Class r = m.getReturnType();
			Class[] types = m.getParameterTypes();
			CodeBuilder code = cc.createInstancePrivateMethod(m);
			boolean isInterface = m.getDeclaringClass().isInterface();
			if (!isInterface) {
				code.code("try {");
			}
			if (!Void.TYPE.equals(r)) {
				code.code("return ($r) ");
			}
			if (isInterface) {
				code.code("(").castObject(m.getDeclaringClass()).code(BEAN_FIELD_NAME);
				code.code(").").code(m.getName()).code("($$);");
			} else {
				code.code(BEAN_FIELD_NAME).code(".getClass().getMethod(");
				code.insert(m.getName()).code(", ").insert(types).code(")")
						.code(".invoke(");
				code.code(BEAN_FIELD_NAME).code(", $args);");
			}
			if (!isInterface) {
				code.code("} catch (").code(
						InvocationTargetException.class.getName());
				code.code(" e) {throw e.getCause();}");
			}
			code.end();
		}
	}

	private Collection getMethods(Class c) {
		List methods = new ArrayList();
		methods.addAll(Arrays.asList(c.getMethods()));
		HashMap map = new HashMap();
		Map pms = getProtectedMethods(c, map);
		methods.addAll(pms.values());
		return methods;
	}

	private Map getProtectedMethods(Class c,
			Map methods) {
		if (c == null)
			return methods;
		for (Method m : c.getDeclaredMethods()) {
			if (isProtected(m.getModifiers())) {
				Object types = Arrays.asList(m.getParameterTypes());
				Object key = Arrays.asList(m.getName(), types);
				if (!methods.containsKey(key)) {
					methods.put(key, m);
				}
			}
		}
		return getProtectedMethods(c.getSuperclass(), methods);
	}

	private void overrideToStringMethod(ClassTemplate cc) {
		try {
			Method toString = Object.class.getMethod("toString");
			MethodBuilder m = cc.createInstancePrivateMethod(toString);
			m.code("return ").code(GET_ENTITY_METHOD);
			m.code("().toString()").semi().end();
		} catch (NoSuchMethodException e) {
			throw new AssertionError(e);
		}
	}

	private void overrideEqualsMethod(ClassTemplate cc) {
		try {
			Method hashCode = Object.class.getMethod("hashCode");
			MethodBuilder m = cc.createInstancePrivateMethod(hashCode);
			m.code("return ").code(GET_ENTITY_METHOD);
			m.code("().hashCode()").semi().end();
			Method equals = Object.class.getMethod("equals", Object.class);
			m = cc.createInstancePrivateMethod(equals);
			m.code("return ").code(GET_ENTITY_METHOD);
			m.code("().equals($1)").semi().end();
		} catch (NoSuchMethodException e) {
			throw new AssertionError(e);
		}
	}

}