refactored MainWindow and Engine, changed project structure

src/mono/mono.cpp

@@ -0,0 +1,81 @@
+#include "mono.hpp"
+#include <mono/metadata/appdomain.h>
+
+namespace Mono {
+
+template <> MonoClass* getClass<SByte>(){ return mono_get_sbyte_class(); }
+template <> MonoClass* getClass<Byte>(){ return mono_get_byte_class(); }
+template <> MonoClass* getClass<Short>(){ return mono_get_int16_class(); }
+template <> MonoClass* getClass<UShort>(){ return mono_get_uint16_class(); }
+template <> MonoClass* getClass<Int>(){ return mono_get_int32_class(); }
+template <> MonoClass* getClass<UInt>(){ return mono_get_uint32_class(); }
+template <> MonoClass* getClass<Long>(){ return mono_get_int64_class(); }
+template <> MonoClass* getClass<ULong>(){ return mono_get_uint64_class(); }
+template <> MonoClass* getClass<Float>(){ return mono_get_single_class(); }
+template <> MonoClass* getClass<Double>(){ return mono_get_double_class(); }
+template <> MonoClass* getClass<Bool>(){ return mono_get_boolean_class(); }
+template <> MonoClass* getClass<Char>(){ return mono_get_char_class(); }
+template <> MonoClass* getClass<String>(){ return mono_get_string_class(); }
+template <> MonoClass* getClass<Object>(){ return mono_get_object_class(); }
+template <> MonoClass* getClass<Void>(){ return mono_get_void_class(); }
+
+
+void getMethodSignatureTypes(MonoMethod* mono_method,
+        MonoType** return_type,
+        std::vector<MonoType*>& argument_types)
+{
+    auto signature = mono_method_signature(mono_method);
+    void* iter = nullptr;
+    *return_type = mono_signature_get_return_type(signature);
+    MonoType* pt = nullptr;
+    while( (pt = mono_signature_get_params(signature, &iter)) ){
+        argument_types.push_back(pt);
+    }
+}
+
+MonoMethod* tryGetMonoMethod(MonoClass* target_class, const std::string& name,
+        MonoClass* return_class, MonoClass* arg_classes[], size_t arg_classes_size)
+{
+    if(target_class == nullptr)
+        throw UsefulException("target_class is nullptr");
+    
+    // iterate each method
+    void* iter = nullptr;
+    MonoMethod* m = nullptr;
+    std::vector<MonoType*> argument_types;
+    while( (m = mono_class_get_methods(target_class, &iter)) ){
+        // compare name
+        std::string m_name = mono_method_get_name(m);
+        if(m_name != name)
+            continue;
+        
+        argument_types.clear();
+        MonoType* return_type = nullptr;
+        getMethodSignatureTypes(m, &return_type, argument_types);
+        // compare argument count
+        if(argument_types.size() != arg_classes_size)
+            continue;
+        
+        // compare return type
+        if(!mono_metadata_type_equal(return_type, mono_class_get_type(return_class)))
+            continue;
+        
+        // compare argument types
+        bool argument_types_mismatch = false;
+        for(size_t i = 0; i < arg_classes_size; i++){
+            if(!mono_metadata_type_equal(argument_types[i], mono_class_get_type(arg_classes[i]))){
+                argument_types_mismatch = true;
+                break;
+            }
+        }
+        if(argument_types_mismatch)
+            continue;
+        
+        // passed all tests successfully
+        break;
+    }
+
+    return m;
+}
+
+}