Template methods should be replaced with runtime implemented interfaces

[bergerkiller]

Right now we use abstract Template methods with various invoke/invokeVA methods. While this works, it incurs a performance drain for methods that use primitives in parameters or return type, or contain Object parameters that can be exposed to save unneeded casting.

Suggested solution: make Template.Class implementations abstract with abstract methods for all to-be-implemented methods. For example:

public static abstract class EntityClass extends Template.Class<EntityHandle> {
    public final Template.Field.Double locX = new Template.Field.Double();
    //etc.

    public abstract int getTeleportTicks();
    public abstract List<Entity> getPassengers();
    public abstract void move(Object moveType, double dx, double dy, double dz);
}

The EntityClass will also include a 'RAW' constant somewhere to declare all raw, unconverted methods. For the raw class itself this variable will be assigned 'this'.

Instead of calling new on this class, it is extended and further implemented at runtime, then assigned to Template.T variable for later use by the Handle or elsewhere.

Ideally this will be implemented ON TOP of the current template system to avoid compatibility issues.

Benefits:

• Performance improvements (less casting, boxing, unboxing, variable access)
• Reduces the amount of classes that are generated at runtime (permgen space)
• Type-safety for method signatures, instead of Object everywhere
• Better API

Problems:

• Complexity of implementation
• Lazy-loading of methods becomes hard or impossible
• Can no longer use methodName.toMethodAccessor() for legacy API
• Can no longer treat methods as objects, which allowed them to be used as method arguments
• Time to implement (is it really needed?)

[bergerkiller]

This has been improved by runtime-generating the handles. This means that using the Handle type (not the .T template elements) can have improved performance when invoking methods with primitive parameters or return types.