DefaultEntityProxyFactory.java

package jalse.entities;

import static jalse.entities.Entities.isEntitySubtype;

import java.lang.ref.WeakReference;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collections;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger;

import jalse.entities.functions.DefaultFunction;
import jalse.entities.functions.EntityFunction;
import jalse.entities.functions.EntityFunctionResolver;
import jalse.entities.functions.EntityMethodFunction;
import jalse.entities.functions.GetAttributeFunction;
import jalse.entities.functions.GetEntitiesFunction;
import jalse.entities.functions.GetEntityFunction;
import jalse.entities.functions.KillEntitiesFunction;
import jalse.entities.functions.KillEntityFunction;
import jalse.entities.functions.MarkAsTypeFunction;
import jalse.entities.functions.NewEntityFunction;
import jalse.entities.functions.ScheduleForActorFunction;
import jalse.entities.functions.SetAttributeFunction;
import jalse.entities.functions.StreamEntitiesFunction;
import jalse.entities.functions.UnmarkAsTypeFunction;
import jalse.entities.methods.EntityMethod;

/**
 * This is the default {@link EntityProxyFactory} implementation for JALSE. This proxy factory will
 * use {@link EntityFunctionResolver} to resolve an {@link EntityFunction} to translate the proxy
 * {@link Method} calls to {@link EntityMethod}s. Override {@link #addResolverFunctions()} to change
 * what {@link EntityMethodFunction}s are added to the resolver. <br>
 * <br>
 * NOTE: Proxies are cached per {@link Entity} using {@link EntityProxyCache}.
 *
 * @author Elliot Ford
 *
 * @see #uncacheProxyOfEntity(Entity, Class)
 * @see #uncacheProxiesOfEntity(Entity)
 * @see #uncacheAllProxies()
 *
 */
public class DefaultEntityProxyFactory implements EntityProxyFactory {

    /**
     * A {@link WeakHashMap} cache for {@link Entity} proxies.
     *
     * @author Elliot Ford
     *
     * @see Collections#synchronizedMap(Map)
     *
     */
    protected class EntityProxyCache {

	private final Map<Entity, Map<Class<?>, Object>> proxyMap;

	/**
	 * Creates a new entity proxy cache.
	 */
	private EntityProxyCache() {
	    proxyMap = Collections.synchronizedMap(new WeakHashMap<>());
	}

	/**
	 * Either retrieves a proxy from the cache or creates (and caches) a new entity proxy.
	 *
	 * @param e
	 *            Entity to cache type for.
	 * @param type
	 *            Entity type to proxy.
	 * @return Proxy entity of type.
	 *
	 * @see EntityProxyHandler
	 */
	@SuppressWarnings("unchecked")
	public <T extends Entity> T getOrNew(final Entity e, final Class<T> type) {
	    final Map<Class<?>, Object> proxies = proxyMap.computeIfAbsent(e, k -> new ConcurrentHashMap<>());
	    return (T) proxies.computeIfAbsent(type, k -> newEntityProxy(e, k));
	}

	/**
	 * Uncaches all proxies.
	 */
	public void invalidateAll() {
	    proxyMap.clear();
	}

	/**
	 * Uncaches all proxies for an entity.
	 *
	 * @param e
	 *            Entity key.
	 */
	public void invalidateEntity(final Entity e) {
	    proxyMap.remove(e);
	}

	/**
	 * Uncaches a the proxy of the specified type for the entity.
	 *
	 * @param e
	 *            Entity key.
	 * @param type
	 *            Entity type to remove.
	 */
	public void invalidateType(final Entity e, final Class<? extends Entity> type) {
	    final Map<Class<?>, Object> proxies = proxyMap.get(e);
	    if (proxies != null) {
		proxies.remove(type);
		proxyMap.computeIfPresent(e, (k, v) -> v.isEmpty() ? null : v);
	    }
	}

	private Object newEntityProxy(final Entity e, final Class<?> type) {
	    logger.fine(String.format("Creating proxy of type %s for entity %s", type, e.getID()));
	    return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[] { type },
		    new EntityProxyHandler(e));
	}
    }

    /**
     * The {@link InvocationHandler} for the entity proxies. The {@link Entity} is wrapped in a
     * {@link WeakReference}.
     *
     * @author Elliot Ford
     *
     */
    protected class EntityProxyHandler implements InvocationHandler {

	private final WeakReference<Entity> entityRef;

	/**
	 * Creates a new entity proxy handler.
	 *
	 * @param entity
	 *            Entity to proxy events for.
	 */
	private EntityProxyHandler(final Entity entity) {
	    entityRef = new WeakReference<Entity>(entity);
	}

	/**
	 * Gets the entity this proxy is for.
	 *
	 * @return Host entity.
	 *
	 * @see WeakReference
	 */
	public Entity getEntity() {
	    final Entity entity = entityRef.get();
	    if (entity == null) {
		throw new IllegalStateException("Entity reference lost");
	    }
	    return entity;
	}

	@Override
	public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
	    /*
	     * Get Entity reference.
	     */
	    final Entity entity = getEntity();

	    /*
	     * Not an Entity subclass.
	     */
	    final Class<?> declaringClazz = method.getDeclaringClass();
	    if (!isEntitySubtype(declaringClazz)) {
		return method.invoke(entity, args);
	    }

	    /*
	     * Invoke resolved method.
	     */
	    @SuppressWarnings("unchecked")
	    final EntityFunction resolvedType = resolver.resolveType((Class<? extends Entity>) declaringClazz);
	    final EntityMethod entityMethod = resolvedType.apply(method);
	    return entityMethod.invoke(proxy, entity, args);
	}
    }

    private static final Logger logger = Logger.getLogger(DefaultEntityProxyFactory.class.getName());

    /**
     * Resolver for entity types.
     */
    protected final EntityFunctionResolver resolver;

    /**
     * Proxy cache for entities.
     */
    protected final EntityProxyCache cache;

    /**
     * Creates a new DefaultEntityProxyFactory.
     *
     * @see #addResolverFunctions()
     */
    public DefaultEntityProxyFactory() {
	resolver = new EntityFunctionResolver();
	cache = new EntityProxyCache();
	addResolverFunctions();
    }

    /**
     * Adds the {@link EntityMethodFunction}s to the resolver.
     *
     * @see DefaultFunction
     * @see GetAttributeFunction
     * @see SetAttributeFunction
     * @see NewEntityFunction
     * @see GetEntityFunction
     * @see StreamEntitiesFunction
     * @see GetEntitiesFunction
     * @see KillEntityFunction
     * @see KillEntitiesFunction
     * @see MarkAsTypeFunction
     * @see UnmarkAsTypeFunction
     * @see ScheduleForActorFunction
     */
    protected void addResolverFunctions() {
	resolver.addMethodFunction(new DefaultFunction());
	resolver.addMethodFunction(new GetAttributeFunction());
	resolver.addMethodFunction(new SetAttributeFunction());
	resolver.addMethodFunction(new NewEntityFunction());
	resolver.addMethodFunction(new GetEntityFunction());
	resolver.addMethodFunction(new StreamEntitiesFunction());
	resolver.addMethodFunction(new GetEntitiesFunction());
	resolver.addMethodFunction(new KillEntityFunction());
	resolver.addMethodFunction(new KillEntitiesFunction());
	resolver.addMethodFunction(new MarkAsTypeFunction());
	resolver.addMethodFunction(new UnmarkAsTypeFunction());
	resolver.addMethodFunction(new ScheduleForActorFunction());
    }

    @Override
    public boolean isProxyEntity(final Entity e) {
	return Proxy.isProxyClass(e.getClass()) && Proxy.getInvocationHandler(e) instanceof EntityProxyHandler;
    }

    @Override
    public <T extends Entity> T proxyOfEntity(final Entity e, final Class<T> type) {
	validateType(type);
	return cache.getOrNew(e, type);
    }

    /**
     * Uncaches all proxies.
     */
    public void uncacheAllProxies() {
	resolver.unresolveAllTypes();
	cache.invalidateAll();
    }

    /**
     * Uncaches all proxies for an entity.
     *
     * @param e
     *            Entity to uncache for.
     */
    public void uncacheProxiesOfEntity(final Entity e) {
	cache.invalidateEntity(e);
    }

    /**
     * Uncaches the specific type proxy for an entity.
     *
     * @param e
     *            Entity to uncache for.
     * @param type
     *            Proxy type.
     */
    public void uncacheProxyOfEntity(final Entity e, final Class<? extends Entity> type) {
	cache.invalidateType(e, type);
    }

    @Override
    public void validateType(final Class<? extends Entity> type) {
	resolver.resolveType(type);
    }
}