var classLoader = createObject("java", "java.lang.ClassLoader").getSystemClassLoader();
var objectClass = classLoader.loadClass("java.lang.Object");
_setArray(createObject("java", "java.lang.reflect.Array"));
_setClassMethod(objectClass.getMethod("getClass", JavaCast("null", 0)));
_setObjectClass(objectClass);
_setClass(arguments.class);
_setModifier(createObject("java", "java.lang.reflect.Modifier"));
_setStaticFields();
_initMethodCollection();
return this;
var constructor = 0;
var instance = 0;
//make sure we only ever have one instance
if(_hasClassInstance())
{
return _getClassInstance();
}
constructor = _resolveMethodByParams("Constructor", _getClass().getConstructors(), arguments);
instance = constructor.newInstance(_buildArgumentArray(arguments));
_setClassInstance(instance);
return _getClassInstance();
var method = _findMethod(arguments.missingMethodName, arguments.missingMethodArguments);
if(_getModifier().isStatic(method.getModifiers()))
{
return method.invoke(JavaCast("null", 0), _buildArgumentArray(arguments.missingMethodArguments));
}
else
{
if(NOT _hasClassInstance())
{
//run the default constructor, just like in normal CF, if there is no instance
init();
}
return method.invoke(_getClassInstance(), _buildArgumentArray(arguments.missingMethodArguments));
}
var fields = _getClass().getFields();
var counter = 1;
var len = ArrayLen(fields);
var field = 0;
for(; counter <= len; counter++)
{
field = fields[counter];
if(_getModifier().isStatic(field.getModifiers()))
{
this[field.getName()] = field.get(JavaCast("null", 0));
}
}
var len = StructCount(args);
var objArray = _getArray().newInstance(_getObjectClass(), len);
var counter = 1;
var obj = 0;
for(; counter <= len; counter++)
{
obj = args[counter];
_getArray().set(objArray, counter - 1, obj);
}
return objArray;
var decision = 0;
if(StructKeyExists(_getMethodCollection(), arguments.methodName))
{
decision = StructFind(_getMethodCollection(), arguments.methodName);
//if there is only one option, try it, it's only going to throw a runtime exception if it doesn't work.
if(ArrayLen(decision) == 1)
{
return decision[1];
}
else
{
return _resolveMethodByParams(arguments.methodName, decision, arguments.methodArgs);
}
}
throwException("JavaProxy.MethodNotFoundException", "Could not find the designated method", "Could not find the method '#arguments.methodName#' in the class #_getClass().getName()#");
var decisionLen = ArrayLen(arguments.decision);
var method = 0;
var counter = 1;
var argLen = ArrayLen(arguments.methodArgs);
var parameters = 0;
var paramLen = 0;
var pCounter = 0;
var param = 0;
var class = 0;
var found = true;
for(; counter <= decisionLen; counter++)
{
method = arguments.decision[counter];
parameters = method.getParameterTypes();
paramLen = ArrayLen(parameters);
found = true;
if(argLen eq paramLen)
{
for(pCounter = 1; pCounter <= paramLen AND found; pCounter++)
{
param = parameters[pCounter];
class = _getClassMethod().invoke(arguments.methodArgs[pCounter], JavaCast("null", 0));
if(param.isAssignableFrom(class))
{
found = true;
}
else if(param.isPrimitive()) //if it's a primitive, it can be mapped to object primtive classes
{
if(param.getName() eq "boolean" AND class.getName() eq "java.lang.Boolean")
{
found = true;
}
else if(param.getName() eq "int" AND class.getName() eq "java.lang.Integer")
{
found = true;
}
else if(param.getName() eq "long" AND class.getName() eq "java.lang.Long")
{
found = true;
}
else if(param.getName() eq "float" AND class.getName() eq "java.lang.Float")
{
found = true;
}
else if(param.getName() eq "double" AND class.getName() eq "java.lang.Double")
{
found = true;
}
else if(param.getName() eq "char" AND class.getName() eq "java.lang.Character")
{
found = true;
}
else if(param.getName() eq "byte" AND class.getName() eq "java.lang.Byte")
{
found = true;
}
else if(param.getName() eq "short" AND class.getName() eq "java.lang.Short")
{
found = true;
}
else
{
found = false;
}
}
else
{
found = false;
}
}
if(found)
{
return method;
}
}
}
throwException("JavaProxy.MethodNotFoundException", "Could not find the designated method", "Could not find the method '#arguments.methodName#' in the class #_getClass().getName()#");
var methods = _getClass().getMethods();
var len = ArrayLen(methods);
var counter = 1;
var method = 0;
_setMethodCollection(StructNew());
for(; counter <= len; counter++)
{
method = methods[counter];
if(NOT StructKeyExists(_getMethodCollection(), method.getName()))
{
StructInsert(_getMethodCollection(), method.getName(), ArrayNew(1));
}
ArrayAppend(StructFind(_getMethodCollection(), method.getName()), method);
}