Reflection.clcl

class Field
{
    include MObjectBase;

    flags:long;
    name:String;
    resultType:String;
    #value:Anonymous;

    def initialize() {}

    def clone():Field {
        result := Field();

        result.flags = self.flags;
        if(self.name.identifyWith(null).negative()) {
            result.name = self.name.clone();
        }
        if(self.resultType.identifyWith(null).negative()) {
            result.resultType = self.resultType.clone();
        }

        return result;
    }

    def private():bool {
        return (self.flags & Clover.FIELD_FLAGS_PRIVATE).to_bool;
    }

    def protected():bool {
        return (self.flags & Clover.FIELD_FLAGS_PROTECTED).to_bool;
    }
}

class MethodParam
{
    include MObjectBase;

    name:String;
    type:String;

    def initialize() {}

    def clone(): MethodParam {
        result := MethodParam();

        if(self.name.identifyWith(null).negative()) {
            result.name = self.name.clone();
        }
        if(self.type.identifyWith(null).negative()) {
            result.type = self.type.clone();
        }

        return result;
    }
}

class Method
{
    include MObjectBase;

    flags:long;
    name:String;
    path:String;
    methodNameAndParams:String;
    index:int;

    params:MethodParam[];

    resultType:String;

    varNum:int;

    genericsParamTypes:String[];

    def initialize() {}

    def clone(): Method {
        result := Method();

        result.flags = self.flags;
        if(self.name.identifyWith(null).negative()) {
            result.name = self.name.clone();
        }
        if(self.path.identifyWith(null).negative()) {
            result.path = self.path.clone();
        }
        if(self.methodNameAndParams.identifyWith(null).negative()) {
            result.methodNameAndParams = self.methodNameAndParams.clone();
        }
        result.index = self.index;

        if(self.params.identifyWith(null).negative()) {
            result.params = MethodParam[self.params.length]();
            for(i:=0; i<self.params.length; i++) {
                result.params[i] = self.params[i].clone();
            }
        }

        if(self.resultType.identifyWith(null).negative()) {
            result.resultType = self.resultType.clone();
        }
        result.varNum = self.varNum;

        if(self.genericsParamTypes.identifyWith(null).negative()) {
            result.genericsParamTypes = String[self.genericsParamTypes.length]();

            for(j:=0; j<self.genericsParamTypes.length; j++) {
                result.genericsParamTypes[j] = self.genericsParamTypes[j].clone();
            }
        }

        return result;
    }

    def toString():String {
        return methodNameAndParams;
    }
}

class Class
{
    include MObjectBase;

    className:String;
    flags:long;
    genericsParamTypes:String[];
    genericsParamNames:String[];
    numFields:int;
    numClassFields:int;
    numMethods:int;

    JS:bool;

    def initialize() {}

    def initialize(class_name:String, js:bool=false) {
        className = class_name;
        flags = Clover.getClassFlags(class_name, js);
        genericsParamTypes = Clover.getClassGenericsParamTypes(class_name,js);
        genericsParamNames = Clover.getClassGenericsParamNames(class_name,js);
        numFields = Clover.getNumFields(class_name,js);
        numClassFields = Clover.getNumClassFields(class_name,js);
        numMethods = Clover.getNumMethods(class_name,js);
        JS = js;
    }

    def clone():Class {
        result := Class();

        if(self.className.identifyWith(null).negative()) {
            result.className = self.className.clone();
        }
        result.flags = self.flags;
        if(self.genericsParamTypes.identifyWith(null).negative()) {
            result.genericsParamTypes = String[self.genericsParamTypes.length]();
            for(i:=0; i<self.genericsParamTypes.length; i++) {
                result.genericsParamTypes[i] = self.genericsParamTypes[i].clone();
            }
        }
        if(self.genericsParamNames.identifyWith(null).negative()) {
            result.genericsParamNames = String[self.genericsParamNames.length]();
            for(j:=0; j<self.genericsParamNames.length; j++) {
                result.genericsParamNames[j] = self.genericsParamNames[j].clone();
            }
        }
        result.numFields = self.numFields;
        result.numClassFields = self.numClassFields;
        result.numMethods = self.numMethods;

        return result;
    }

    def equals(right:Class): bool {
        return self.className.equals(right.className);
    }

    def toString(): String {
        return self.className;
    }

    def appendField(name:String, type:String) {
        Clover.appendField(className, name, type, JS);
    }
    def appendMethod(code:String) {
        Clover.appendMethod(className, code, JS);
    }
    def appendMethod(method_index:int, code:String) {
        Clover.appendMethod(className, method_index, code, JS);
    }
    def declareMethod(code:String):int {
        return Clover.declareMethod(className, code);
    }
    def appendClassField(name:String, type:String) {
        Clover.appendClassField(className, name, type, JS);
    }
    def getField(index:int): Field {
        return Clover.getField(className, index, JS);
    }
    def getField(name:String): Field? {
        for(i:=0; i<numFields; i++) {
            field := getField(i);

            if(field.name.equals(name)) {
                return field;
            }
        }

        return null;
    }
    def getClassField(index:int): Field {
        return Clover.getClassField(className, index, JS);
    }
    def getClassField(name:String): Field? {
        for(i:=0; i<numClassFields; i++) {
            field := getClassField(i);

            if(field.name.equals(name)) {
                return field;
            }
        }

        return null;
    }
    def getMethod(index:int): Method {
        return Clover.getMethod(className, index, JS);
    }
    def getMethod(name:String): Method? {
        for(i:=numMethods-1; i>=0; i--) { # reverse search for multiple definition
            method := getMethod(i);

            if(method.name.equals(name)) {
                return method;
            }
        }

        return null;
    }
    def getMethod(name:String, param_num:int, class_method:bool): Method? {
        for(i:=numMethods-1; i>=0; i--) { # reverse search for multiple definition
            method := getMethod(i);

            if(method.name.equals(name) && method.params.length == param_num
                && class_method == (method.flags & Clover.METHOD_FLAGS_CLASS_METHOD).to_bool) 
            {
                return method;
            }
        }

        return null;
    }
    def getMethods():List<Method> {
        result := List<Method>();
        for(i:=0; i<numMethods; i++) {
            result.add(getMethod(i));
        }
        return result;
    }
    def getFields():List<Field> {
        result := List<Field>();
        for(i:=0; i<numFields; i++) {
            result.add(getField(i));
        }
        return result;
    }
    def getClassFields():List<Field> {
        result := List<Field>();
        for(i:=0; i<numClassFields; i++) {
            result.add(getClassField(i));
        }
        return result;
    }
    def getClassMethods():List<Method> {
        result := List<Method>();
        for(i:=0; i<numMethods; i++) {
            it := getMethod(i);
            
            if((it.flags & Clover.METHOD_FLAGS_CLASS_METHOD).to_bool) {
                result.push(it);
            }
        }
        
        return result;
    }
    def getNoneClassMethods():List<Method> {
        result := List<Method>();
        for(i:=0; i<numMethods; i++) {
            it := getMethod(i);
            
            if(!((it.flags & Clover.METHOD_FLAGS_CLASS_METHOD).to_bool)) {
                result.add(it);
            }
        }
        
        return result;
    }
    def createObject(): Anonymous {
        return Clover.createObject(className, JS);
    }
    def createArray(size:int): Anonymous {
        return Clover.createArray(className, size);
    }

    def isInterface():bool {
        return (self.flags & Clover.CLASS_FLAGS_INTERFACE).to_bool;
    }
}

inherit Clover
{
    def appendField(class_name:String, name:String, type:String, js:bool=false):static native throws Exception;
    def appendMethod(class_name:String, code:String, js:bool=false): static native throws Exception;
    def appendMethod(class_name:String, method_index:int, code:String, js:bool=false): static native throws Exception;
    def appendClassField(class_name:String, name:String, type:String, js:bool=false):static native throws Exception;
    def appendClass(code:String):static native throws Exception;
    def declareMethod(class_name:String, code:String): static native int throws Exception;

    def getField(class_name:String, index:int, js:bool=false):static native Field throws Exception;
    def getClassField(class_name:String, index:int,js:bool=false):static native Field throws Exception;
    def getMethod(class_name:String, index:int, js:bool=false):static native Method throws Exception;
    def getClassFlags(class_name:String, js:bool=false): static native long throws Exception;
    def getClassGenericsParamTypes(class_name:String, js:bool=false): static native String[] throws Exception;
    def getClassGenericsParamNames(class_name:String, js:bool=false): static native String[] throws Exception;
    def getNumFields(class_name:String, js:bool=false): static native int throws Exception;
    def getNumClassFields(class_name:String, js:bool=false): static native int throws Exception;
    def getNumMethods(class_name:String, js:bool=false): static native int throws Exception;
    def isLoadedClass(class_name:String, js:bool=false): static native bool throws Exception;
    def isDefinedClass(class_name:String, js:bool=false): static native bool throws Exception;
    def createObject(class_name:String, js:bool=false): static native Anonymous;

    def isTypedefedClass(class_name:String, class_name2:String, js:bool=false): static native bool;

    def isPrimitiveClass(name:String):static bool {
        return name.equals("int") || isTypedefedClass(name, "int") || name.equals("uint") || isTypedefedClass(name, "uint") || name.equals("byte") || isTypedefedClass(name, "byte") || name.equals("ubyte") || isTypedefedClass(name, "ubyte") || name.equals("short") || isTypedefedClass(name, "short") || name.equals("ushort") || isTypedefedClass(name, "ushort") || name.equals("long") || isTypedefedClass(name, "long") || name.equals("ulong") || isTypedefedClass(name, "ulong") || name.equals("float") || isTypedefedClass(name, "float") || name.equals("double") || isTypedefedClass(name, "double") || name.equals("pointer") || isTypedefedClass(name, "pointer") || name.equals("char") || isTypedefedClass(name, "char") ||  name.equals("bool") || isTypedefedClass(name, "bool") || name.match(/lambda$|lambda\(\)|lambda\(.*/) || isTypedefedClass(name, "lambda") || name.equals("regex")|| isTypedefedClass(name, "regex") ;
    }
    def primitiveClassToBoxingClass(name:String):static String {
        when(name) {
            case ("int") {
                return "Integer";
            }
            case ("uint") {
                return "UInteger";
            }
            case ("byte") {
                return "Byte";
            }
            case ("ubyte") {
                return "UByte";
            }
            case ("short") {
                return "Short";
            }
            case ("ushort") {
                return "UShort";
            }
            case ("long") {
                return "Long";
            }
            case ("ulong") {
                return "ULong";
            }
            case ("float") {
                return "Float";
            }
            case ("double") {
                return "Double";
            }
            case ("pointer") {
                return "Pointer";
            }
            case ("char") {
                return "Char";
            }
            case ("bool") {
                return "Bool";
            }

            else {
                return name;
            }
        }
    }
    def boxingClassToPrimitiveClass(name:String):static String {
        when(name) {
            case ("Integer") {
                return "int";
            }
            case ("UInteger") {
                return "uint";
            }
            case ("Byte") {
                return "byte";
            }
            case ("UByte") {
                return "ubyte";
            }
            case ("Short") {
                return "short";
            }
            case ("UShort") {
                return "ushort";
            }
            case ("Long") {
                return "long";
            }
            case ("ULong") {
                return "ulong";
            }
            case ("Float") {
                return "float";
            }
            case ("Double") {
                return "double";
            }
            case ("Pointer") {
                return "pointer";
            }
            case ("Char") {
                return "char";
            }
            case ("Bool") {
                return "bool";
            }

            else {
                return name;
            }
        }
    }


    def initialize_reflection(): static native;

    FIELD_FLAGS_PRIVATE:static long;
    FIELD_FLAGS_PROTECTED:static long;

    METHOD_FLAGS_NATIVE:static long;
    METHOD_FLAGS_CLASS_METHOD:static long;

    CLASS_FLAGS_PRIMITIVE:static long;
    CLASS_FLAGS_INTERFACE:static long;
    CLASS_FLAGS_MODIFIED:static long;
    CLASS_FLAGS_ALLOCATED:static long;
    CLASS_FLAGS_DYNAMIC_CLASS:static long;
    CLASS_FLAGS_NO_FREE_OBJECT:static long;

    def initialize():static {
        inherit();

        Clover.initialize_reflection();

        Clover.initializeMethodDefinedClasses = List<Class>();
        Clover.cloneMethodDefinedClasses = List<Class>();
        Clover.initializeMethodDefinedClassMethodIndexes = List<Integer>();
        Clover.cloneMethodDefinedClassMethodIndexes = List<Integer>();
        nothingMethodDefinedClasses = List<Class>();
        nothingMethodDefinedClassMethodIndexes = List<Integer>();
    }

    def getAllClassName(): static native String[];

    def getModifiedClass(): static EqualableList<Class> {
        result := EqualableList<Class>();

        getAllClassName().each {
            klass := Class(it);

            if((klass.flags & CLASS_FLAGS_MODIFIED).to_bool) {
                result.add(klass);
            }
        }

        return result;
    }

    initializeMethodDefinedClasses:static List<Class>;
    initializeMethodDefinedClassMethodIndexes:static List<Integer>;
    cloneMethodDefinedClasses:static List<Class>;
    cloneMethodDefinedClassMethodIndexes:static List<Integer>;
    nothingMethodDefinedClasses:static List<Class>;
    nothingMethodDefinedClassMethodIndexes:static List<Integer>;

    def compileTimeScriptingOnDeclareTime():static {
    }

    def compileTimeScripting():static {
    }
}

inherit Array<T:Object>
{
    def clone():Array<T> {
        result := Array<T>();

        if(!self.items.identifyWith(null)) {
            class_name := self.items.className().subString(0, -3);

            klass := Class(class_name);
            result.items = klass.createArray(self.items.length);
            
            for(i:=0; i<self.items.length; i++) {
                result.items[i] = self.items[i];
            }
        }

        return result;
    }
}

inherit EqualableArray <T:IEqualable>
{
    def initialize(num:int) {
        self.items = Clover.createArray("Object", num);
    }

    def clone():EqualableArray<T> {
        result := EqualableArray<T>();

        if(!self.items.identifyWith(null)) {
            class_name := self.items.className().subString(0, -3);

            klass := Class(class_name);
            result.items = klass.createArray(self.items.length);
            
            for(i:=0; i<self.items.length; i++) {
                result.items[i] = self.items[i].clone();
            }
        }

        return result;
    }
}

inherit SortableArray <T:ISortable>
{
    def initialize(num:int) {
        self.items = Clover.createArray("Object", num);
    }

    def clone():SortableArray<T> {
        result := SortableArray<T>();

        if(!self.items.identifyWith(null)) {
            class_name := self.items.className().subString(0, -3);

            klass := Class(class_name);
            result.items = klass.createArray(self.items.length);
            
            for(i:=0; i<self.items.length; i++) {
                result.items[i] = self.items[i].clone();
            }
        }

        return result;
    }
}