csharp: Add code to update IList passed as @in variable

If the array was modified, we update the passed @in variable.

src/bin/eolian_mono/eolian/mono/events.hh

@@ -129,9 +129,18 @@ struct unpack_event_args_visitor
    {
       return as_generator("(Efl.Eo.Globals.CreateWrapperFor(info) as " + name_helpers::klass_full_concrete_name(cls) + ")").generate(sink, attributes::unused, *context);
    }
-   bool operator()(attributes::complex_type_def const&) const
+   bool operator()(attributes::complex_type_def const& types) const
    {
-      return as_generator("new " << eolian_mono::type << "(info, false, false)").generate(sink, type, *context);
+      if (types.outer.base_type == "array")
+        return as_generator("Efl.Eo.Globals.NativeArrayTo" << eolian_mono::type << "(info)").generate(sink, type, *context);
+      else if (types.outer.base_type == "list")
+        return as_generator("Efl.Eo.Globals.NativeListTo" << eolian_mono::type << "(info)").generate(sink, type, *context);
+      else if (types.outer.base_type == "iterator")
+        return as_generator("Efl.Eo.Globals.IteratorTo" << eolian_mono::type << "(info)").generate(sink, type, *context);
+      else if (types.outer.base_type == "accessor")
+        return as_generator("Efl.Eo.Globals.AccessorTo" << eolian_mono::type << "(info)").generate(sink, type, *context);
+      else
+        return as_generator("new " << eolian_mono::type << "(info, false, false)").generate(sink, type, *context);
    }
 };
 
@@ -237,10 +246,23 @@ struct pack_event_info_and_call_visitor
       return as_generator(indent << "IntPtr info = e.arg.NativeHandle;\n"
                           << indent << this->native_call).generate(sink, attributes::unused, *context);
    }
-   bool operator()(attributes::complex_type_def const&) const
+   bool operator()(attributes::complex_type_def const& type) const
    {
       auto const& indent = current_indentation(*context);
-      return as_generator(indent << "IntPtr info = e.arg.Handle;\n"
+      if (type.outer.base_type == "array")
+        return as_generator(indent << "IntPtr info = Efl.Eo.Globals.IListToNativeArray(e.arg);\n"
+                            << indent << this->native_call).generate(sink, attributes::unused, *context);
+      else if (type.outer.base_type == "list")
+        return as_generator(indent << "IntPtr info = Efl.Eo.Globals.IListToNativeList(e.arg);\n"
+                            << indent << this->native_call).generate(sink, attributes::unused, *context);
+      else if (type.outer.base_type == "iterator")
+        return as_generator(indent << "IntPtr info = Efl.Eo.Globals.IEnumerableToIterator(e.arg);\n"
+                            << indent << this->native_call).generate(sink, attributes::unused, *context);
+      else if (type.outer.base_type == "accessor")
+        return as_generator(indent << "IntPtr info = Efl.Eo.Globals.IEnumerableToAccessor(e.arg);\n"
+                            << indent << this->native_call).generate(sink, attributes::unused, *context);
+      else
+        return as_generator(indent << "IntPtr info = e.arg.Handle;\n"
                           << indent << this->native_call).generate(sink, attributes::unused, *context);
    }
 };

src/bin/eolian_mono/eolian/mono/parameter.hh

@@ -625,30 +625,44 @@ struct native_convert_in_variable_generator
                << ");\n"
             ).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
        }
-     else if (param.type.c_type == "Eina_Array *" || param.type.c_type == "const Eina_Array *"
-              || param.type.c_type == "Eina_List *" || param.type.c_type == "const Eina_List *"
-     )
+     else if (param.type.c_type == "Eina_List *" || param.type.c_type == "const Eina_List *")
        {
           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
           if (!complex)
             return false;
           return as_generator(
-               "var " << string << " = new " << type << "(" << escape_keyword(param.param_name)
-               << ", " << (param.type.has_own ? "true" : "false")
-               << ", " << (complex->subtypes.front().is_value_type || complex->subtypes.front().has_own ? "true" : "false")
+               "var " << string << " = Efl.Eo.Globals.NativeListTo" << type << "(" << escape_keyword(param.param_name)
                << ");\n"
             ).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
        }
-     else if (param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
-             || param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
-     )
+     else if (param.type.c_type == "Eina_Array *" || param.type.c_type == "const Eina_Array *")
        {
           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
           if (!complex)
             return false;
           return as_generator(
-               "var " << string << " = new " << type << "(" << escape_keyword(param.param_name)
-               << ", " << (param.type.has_own ? "true" : "false")
+               "var " << string << " = Efl.Eo.Globals.NativeArrayTo" << type << "(" << escape_keyword(param.param_name)
+               << ");\n"
+            ).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
+       }
+
+     else if (param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *")
+       {
+          attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+          if (!complex)
+            return false;
+          return as_generator(
+               "var " << string << " = Efl.Eo.Globals.IteratorTo" << type << "(" << escape_keyword(param.param_name)
+               << ");\n"
+            ).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
+       }
+     else if (param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *")
+       {
+          attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+          if (!complex)
+            return false;
+          return as_generator(
+               "var " << string << " = Efl.Eo.Globals.AccessorTo" << type << "(" << escape_keyword(param.param_name)
                << ");\n"
             ).generate(sink, std::make_tuple(in_variable_name(param.param_name), param.type), context);
        }
@@ -722,35 +736,48 @@ struct convert_in_variable_generator
                   ).generate(sink, attributes::unused, context))
              return false;
         }
-      else if (param.type.c_type == "Eina_Array *" || param.type.c_type == "const Eina_Array *"
-               || param.type.c_type == "Eina_List *" || param.type.c_type == "const Eina_List *"
-               || param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
-               || param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
-      )
+      else if (param.type.c_type == "Eina_Array *" || param.type.c_type == "const Eina_Array *")
         {
            attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
            if (!complex)
              return false;
            auto var_name = in_variable_name(param.param_name);
            if (!as_generator(
-                 "var " << string << " = " << escape_keyword(param.param_name) << ".Handle;\n"
+                 "var " << string << " = " << "Efl.Eo.Globals.IListToNativeArray(" << escape_keyword(param.param_name) << ");\n"
               ).generate(sink, var_name, context))
              return false;
-           if (param.type.has_own && !as_generator(
-                     escape_keyword(param.param_name) << ".Own = false;\n"
-                  ).generate(sink, attributes::unused, context))
+        }
+      else if (param.type.c_type == "Eina_List *" || param.type.c_type == "const Eina_List *")
+        {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+           if (!complex)
              return false;
-
-           // Iterators and Accessors can't own their content.
-           if (param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
-               || param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
-              )
-             return true;
-
-           if (!complex->subtypes.front().is_value_type && complex->subtypes.front().has_own
-               && !as_generator(
-                     escape_keyword(param.param_name) << ".OwnContent = false;\n"
-                  ).generate(sink, attributes::unused, context))
+           auto var_name = in_variable_name(param.param_name);
+           if (!as_generator(
+                 "var " << string << " = " << "Efl.Eo.Globals.IListToNativeList(" << escape_keyword(param.param_name) << ");\n"
+              ).generate(sink, var_name, context))
+             return false;
+        }
+      else if (param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *")
+        {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+           if (!complex)
+             return false;
+           auto var_name = in_variable_name(param.param_name);
+           if (!as_generator(
+                 "var " << string << " = " << "Efl.Eo.Globals.IEnumerableToIterator(" << escape_keyword(param.param_name) << ");\n"
+              ).generate(sink, var_name, context))
+             return false;
+        }
+      else if (param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *")
+        {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+           if (!complex)
+             return false;
+           auto var_name = in_variable_name(param.param_name);
+           if (!as_generator(
+                 "var " << string << " = " << "Efl.Eo.Globals.IEnumerableToAccessor(" << escape_keyword(param.param_name) << ");\n"
+              ).generate(sink, var_name, context))
              return false;
         }
      else if (param.type.c_type == "Eina_Value")
@@ -975,7 +1002,17 @@ struct convert_out_assign_generator
                || param_is_acceptable(param, "Eina_Array *", !WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_Array *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_Array *", !WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "Eina_List *", WANT_OWN, WANT_OUT)
+              )
+        {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+           if (!complex)
+             return false;
+           return as_generator(
+               string << " = Efl.Eo.Globals.NativeArrayTo" << type << "(" << string
+               << ");\n"
+             ).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type, out_variable_name(param.param_name)), context);
+        }
+      else if (param_is_acceptable(param, "Eina_List *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "Eina_List *", !WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_List *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_List *", !WANT_OWN, WANT_OUT)
@@ -985,17 +1022,11 @@ struct convert_out_assign_generator
            if (!complex)
              return false;
            return as_generator(
-               string << " = new " << type << "(" << string
-               << ", " << (param.type.has_own ? "true" : "false")
-               << ", " << (complex->subtypes.front().is_value_type || complex->subtypes.front().has_own ? "true" : "false")
+               string << " = Efl.Eo.Globals.NativeListTo" << type << "(" << string
                << ");\n"
              ).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type, out_variable_name(param.param_name)), context);
         }
-       else if (param_is_acceptable(param, "Eina_Iterator *", WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "Eina_Iterator *", !WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "const Eina_Iterator *", WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "const Eina_Iterator *", !WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
+       else if (param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
@@ -1005,8 +1036,21 @@ struct convert_out_assign_generator
            if (!complex)
              return false;
            return as_generator(
-               string << " = new " << type << "(" << string
-               << ", " << (param.type.has_own ? "true" : "false")
+               string << " = Efl.Eo.Globals.AccessorTo" << type << "(" << string
+               << ");\n"
+             ).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type, out_variable_name(param.param_name)), context);
+        }
+       else if (param_is_acceptable(param, "Eina_Iterator *", WANT_OWN, WANT_OUT)
+               || param_is_acceptable(param, "Eina_Iterator *", !WANT_OWN, WANT_OUT)
+               || param_is_acceptable(param, "const Eina_Iterator *", WANT_OWN, WANT_OUT)
+               || param_is_acceptable(param, "const Eina_Iterator *", !WANT_OWN, WANT_OUT)
+              )
+        {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+           if (!complex)
+             return false;
+           return as_generator(
+               string << " = Efl.Eo.Globals.IteratorTo" << type << "(" << string
                << ");\n"
              ).generate(sink, std::make_tuple(escape_keyword(param.param_name), param.type, out_variable_name(param.param_name)), context);
         }
@@ -1051,6 +1095,17 @@ struct convert_in_ptr_assign_generator
                  string << " = " << in_variable_name(param.param_name) << ";\n"
              ).generate(sink, escape_keyword(param.param_name), context);
         }
+      else if (param_is_acceptable(param, "Eina_Array *", WANT_OWN, !WANT_OUT)
+               || param_is_acceptable(param, "Eina_Array *", !WANT_OWN, !WANT_OUT)
+               || param_is_acceptable(param, "const Eina_Array *", WANT_OWN, !WANT_OUT)
+               || param_is_acceptable(param, "const Eina_Array *", !WANT_OWN, !WANT_OUT)
+              )
+        {
+           return as_generator(
+             lit("Efl.Eo.Globals.UpdateListFromNativeArray(") << escape_keyword(param.param_name) << ", " << in_variable_name(param.param_name) << ");\n"
+           ).generate(sink, attributes::unused, context);
+        }
+
 
       return true;
    }
@@ -1108,27 +1163,39 @@ struct convert_return_generator
              .generate(sink, ret_type, context))
              return false;
        }
-     else if (ret_type.c_type == "Eina_Array *" || ret_type.c_type == "const Eina_Array *"
-              || ret_type.c_type == "Eina_List *" || ret_type.c_type == "const Eina_List *"
-             )
+     else if (ret_type.c_type == "Eina_Array *" || ret_type.c_type == "const Eina_Array *")
        {
            attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
            if (!complex)
              return false;
-           if (!as_generator("return new " << type << "(_ret_var, " << std::string{ret_type.has_own ? "true" : "false"}
-                   << ", " << (complex->subtypes.front().is_value_type || complex->subtypes.front().has_own ? "true" : "false")
-                   << ");\n")
-             .generate(sink, ret_type, context))
+           if (!as_generator("return Efl.Eo.Globals.NativeArrayTo" << type << "(_ret_var);")
+                 .generate(sink, ret_type, context))
              return false;
        }
-     else if(ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *"
-              || ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *"
-             )
+     else if (ret_type.c_type == "Eina_List *" || ret_type.c_type == "const Eina_List *")
        {
            attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
            if (!complex)
              return false;
-           if (!as_generator("return new " << type << "(_ret_var, " << std::string{ret_type.has_own ? "true" : "false"} << ");\n")
+           if (!as_generator("return Efl.Eo.Globals.NativeListTo" << type << "(_ret_var);")
+                 .generate(sink, ret_type, context))
+             return false;
+       }
+     else if (ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *")
+       {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
+           if (!complex)
+             return false;
+           if (!as_generator("return Efl.Eo.Globals.AccessorTo" << type << "(_ret_var);")
+                 .generate(sink, ret_type, context))
+             return false;
+       }
+     else if (ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *")
+       {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
+           if (!complex)
+             return false;
+           if (!as_generator("return Efl.Eo.Globals.IteratorTo" << type << "(_ret_var);")
                  .generate(sink, ret_type, context))
              return false;
        }
@@ -1234,16 +1301,32 @@ struct native_convert_out_assign_generator
       else if (param_is_acceptable(param, "Eina_Array *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "Eina_Array *", !WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_Array *", WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "const Eina_Array *", !WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "Eina_List *", WANT_OWN, WANT_OUT)
+               || param_is_acceptable(param, "const Eina_Array *", !WANT_OWN, WANT_OUT))
+        {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+           if (!complex)
+             return false;
+           auto outvar = out_variable_name(param.param_name);
+           if (!as_generator(
+                string << " = Efl.Eo.Globals.IListToNativeArray(" << string << ");\n"
+              ).generate(sink, std::make_tuple(escape_keyword(param.param_name), outvar), context))
+             return false;
+        }
+      else if (param_is_acceptable(param, "Eina_List *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "Eina_List *", !WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_List *", WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "const Eina_List *", !WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "Eina_Iterator *", WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "Eina_Iterator *", !WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "const Eina_Iterator *", WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "const Eina_Iterator *", !WANT_OWN, WANT_OUT)
-               || param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
+               || param_is_acceptable(param, "const Eina_List *", !WANT_OWN, WANT_OUT))
+        {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+           if (!complex)
+             return false;
+           auto outvar = out_variable_name(param.param_name);
+           if (!as_generator(
+                string << " = Efl.Eo.Globals.IListToNativeList(" << string << ");\n"
+              ).generate(sink, std::make_tuple(escape_keyword(param.param_name), outvar), context))
+             return false;
+        }
+      else if (param_is_acceptable(param, "Eina_Accessor *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "Eina_Accessor *", !WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_Accessor *", WANT_OWN, WANT_OUT)
                || param_is_acceptable(param, "const Eina_Accessor *", !WANT_OWN, WANT_OUT)
@@ -1254,24 +1337,23 @@ struct native_convert_out_assign_generator
              return false;
            auto outvar = out_variable_name(param.param_name);
            if (!as_generator(
-                string << " = " << string << ".Handle;\n"
+                string << " = Efl.Eo.Globals.IEnumerableToAccessor(" << string << ");\n"
               ).generate(sink, std::make_tuple(escape_keyword(param.param_name), outvar), context))
              return false;
-           if (param.type.has_own && !as_generator(
-                 string << ".Own = false;\n"
-               ).generate(sink, outvar, context))
+        }
+      else if (param_is_acceptable(param, "Eina_Iterator *", WANT_OWN, WANT_OUT)
+               || param_is_acceptable(param, "Eina_Iterator *", !WANT_OWN, WANT_OUT)
+               || param_is_acceptable(param, "const Eina_Iterator *", WANT_OWN, WANT_OUT)
+               || param_is_acceptable(param, "const Eina_Iterator *", !WANT_OWN, WANT_OUT)
+             )
+        {
+           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&param.type.original_type);
+           if (!complex)
              return false;
-
-           // Iterators and Accessors can't own their content.
-           if (param.type.c_type == "Eina_Iterator *" || param.type.c_type == "const Eina_Iterator *"
-               || param.type.c_type == "Eina_Accessor *" || param.type.c_type == "const Eina_Accessor *"
-              )
-             return true;
-
-           if (!complex->subtypes.front().is_value_type && complex->subtypes.front().has_own
-               && !as_generator(
-                 string << ".OwnContent = false;\n"
-               ).generate(sink, outvar, context))
+           auto outvar = out_variable_name(param.param_name);
+           if (!as_generator(
+                string << " = Efl.Eo.Globals.IEnumerableToIterator(" << string << ");\n"
+              ).generate(sink, std::make_tuple(escape_keyword(param.param_name), outvar), context))
              return false;
         }
       return true;
@@ -1284,7 +1366,13 @@ struct native_convert_return_variable_generator
    template <typename OutputIterator, typename Context>
    bool generate(OutputIterator sink, attributes::type_def const& ret_type, Context const& context) const
    {
-     if (ret_type.c_type != "void")
+     if (ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *" ||
+         ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *")
+       return as_generator(
+                    type << " _ret_var = null;"
+               ).generate(sink, ret_type, context);
+
+     else if (ret_type.c_type != "void")
        return as_generator(
                     type << " _ret_var = default(" << type << ");"
                ).generate(sink, std::make_tuple(ret_type, ret_type), context);
@@ -1377,31 +1465,30 @@ struct native_convert_return_generator
           return as_generator("return _ret_var.Handle;")
             .generate(sink, attributes::unused, context);
        }
-     else if (ret_type.c_type == "Eina_Array *" || ret_type.c_type == "const Eina_Array *"
-              || ret_type.c_type == "Eina_List *" || ret_type.c_type == "const Eina_List *"
-              || ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *"
-              || ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *"
-     )
+     else if (ret_type.c_type == "Eina_Array *" || ret_type.c_type == "const Eina_Array *")
        {
           attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
           if (!complex)
             return false;
-          if (ret_type.has_own && !as_generator("_ret_var.Own = false; ")
-              .generate(sink, attributes::unused, context))
+          return as_generator("return Efl.Eo.Globals.IListToNativeArray(_ret_var);")
+            .generate(sink, attributes::unused, context);
+       }
+     else if (ret_type.c_type == "Eina_List *" || ret_type.c_type == "const Eina_List *")
+       {
+          attributes::complex_type_def const* complex = efl::eina::get<attributes::complex_type_def>(&ret_type.original_type);
+          if (!complex)
             return false;
-
-           // Iterators and Accessors can't own their content.
-           if (ret_type.c_type != "Eina_Iterator *" && ret_type.c_type != "const Eina_Iterator *"
-               && ret_type.c_type != "Eina_Accessor *" && ret_type.c_type != "const Eina_Accessor *"
-              )
-             {
-                if (!complex->subtypes.front().is_value_type && complex->subtypes.front().has_own
-                    && !as_generator("_ret_var.OwnContent = false; ")
-                   .generate(sink, attributes::unused, context))
-                  return false;
-             }
-
-          return as_generator("return _ret_var.Handle;")
+          return as_generator("return Efl.Eo.Globals.IListToNativeList(_ret_var);")
+            .generate(sink, attributes::unused, context);
+       }
+     else if (ret_type.c_type == "Eina_Accessor *" || ret_type.c_type == "const Eina_Accessor *")
+       {
+          return as_generator("return Efl.Eo.Globals.IEnumerableToAccessor(_ret_var);")
+            .generate(sink, attributes::unused, context);
+       }
+     else if (ret_type.c_type == "Eina_Iterator *" || ret_type.c_type == "const Eina_Iterator *")
+       {
+          return as_generator("return Efl.Eo.Globals.IEnumerableToIterator(_ret_var);")
             .generate(sink, attributes::unused, context);
        }
      else if (ret_type.c_type != "void")

src/bin/eolian_mono/eolian/mono/struct_definition.hh

@@ -69,10 +69,28 @@ struct to_internal_field_convert_generator
                .generate(sink, std::make_tuple(field_name, field_name), context))
              return false;
         }
-      else if ((complex && (complex->outer.base_type == "array"
-                         || complex->outer.base_type == "list"
-                         || complex->outer.base_type == "iterator"
-                         || complex->outer.base_type == "hash"))
+      else if ((complex && (complex->outer.base_type == "array")))
+        {
+           if (!as_generator(
+                 indent << scope_tab << scope_tab << "_internal_struct." << string << " = Efl.Eo.Globals.IListToNativeArray(_external_struct." << string << ");\n")
+               .generate(sink, std::make_tuple(field_name, field_name), context))
+             return false;
+        }
+      else if ((complex && (complex->outer.base_type == "list")))
+        {
+           if (!as_generator(
+                 indent << scope_tab << scope_tab << "_internal_struct." << string << " = Efl.Eo.Globals.IListToNativeList(_external_struct." << string << ");\n")
+               .generate(sink, std::make_tuple(field_name, field_name), context))
+             return false;
+        }
+      else if ((complex && (complex->outer.base_type == "iterator")))
+        {
+           if (!as_generator(
+                 indent << scope_tab << scope_tab << "_internal_struct." << string << " = Efl.Eo.Globals.IEnumerableToIterator(_external_struct." << string << ");\n")
+               .generate(sink, std::make_tuple(field_name, field_name), context))
+             return false;
+        }
+      else if ((complex && (complex->outer.base_type == "hash"))
             || field.type.c_type == "Eina_Binbuf *" || field.type.c_type == "const Eina_Binbuf *")
         {
            // Always assumes pointer
@@ -187,12 +205,19 @@ struct to_external_field_convert_generator
                .generate(sink, std::make_tuple(field_name, field.type, field_name), context))
              return false;
         }
-      else if (complex && (complex->outer.base_type == "array"
-                        || complex->outer.base_type == "list"))
+      else if (complex && (complex->outer.base_type == "array"))
         {
            // Always assumes pointer
            if (!as_generator(
-                 indent << scope_tab << scope_tab << "_external_struct." << string << " = new " << type << "(_internal_struct." << string << ", false, false);\n")
+                 indent << scope_tab << scope_tab << "_external_struct." << string << " = Efl.Eo.Globals.NativeArrayTo" << type << "(_internal_struct." << string << ");\n")
+               .generate(sink, std::make_tuple(field_name, field.type, field_name), context))
+             return false;
+        }
+      else if (complex && (complex->outer.base_type == "list"))
+        {
+           // Always assumes pointer
+           if (!as_generator(
+                 indent << scope_tab << scope_tab << "_external_struct." << string << " = Efl.Eo.Globals.NativeListTo" << type << "(_internal_struct." << string << ");\n")
                .generate(sink, std::make_tuple(field_name, field.type, field_name), context))
              return false;
         }
@@ -206,7 +231,7 @@ struct to_external_field_convert_generator
       else if (complex && complex->outer.base_type == "iterator")
         {
            if (!as_generator(
-                 indent << scope_tab << scope_tab << "_external_struct." << string << " = new " << type << "(_internal_struct." << string << ", false);\n")
+                 indent << scope_tab << scope_tab << "_external_struct." << string << " = Efl.Eo.Globals.IteratorTo" << type << "(_internal_struct." << string << ");\n")
                .generate(sink, std::make_tuple(field_name, field.type, field_name), context))
              return false;
         }

src/bin/eolian_mono/eolian/mono/type_impl.hh

@@ -380,13 +380,13 @@ struct visitor_generate
         {"list", nullptr, nullptr, [&]
          {
            complex_type_def c = complex;
-           c.outer.base_type = "Eina.List";
+           c.outer.base_type = "IList";
            return c;
          }}
         , {"array", nullptr, nullptr, [&]
            {
            complex_type_def c = complex;
-           c.outer.base_type = "Eina.Array";
+           c.outer.base_type = "IList";
            return c;
          }}
         , {"hash", nullptr, nullptr
@@ -405,14 +405,14 @@ struct visitor_generate
         , {"iterator", nullptr, nullptr, [&]
            {
              complex_type_def c = complex;
-             c.outer.base_type = "Eina.Iterator";
+             c.outer.base_type = "IEnumerable";
              return c;
            }           
           }
         , {"accessor", nullptr, nullptr, [&]
            {
              complex_type_def c = complex;
-             c.outer.base_type = "Eina.Accessor";
+             c.outer.base_type = "IEnumerable";
              return c;
            }           
           }

src/bindings/mono/efl_mono/GenericModel.cs

@@ -31,7 +31,7 @@ public class GenericModel<T> : Efl.Object, Efl.IModel
    }
 
    /// <summary>The list of properties available in the wrapped model.</summary>
-   public Eina.Iterator< System.String> Properties
+   public IEnumerable<System.String> Properties
    {
       get { return GetProperties(); }
    }
@@ -44,7 +44,7 @@ public class GenericModel<T> : Efl.Object, Efl.IModel
 
    /// <summary>The list of properties available in the wrapped model.</summary>
    /// <returns>The list of properties in the model.</returns>
-   public Eina.Iterator<System.String> GetProperties()
+   public IEnumerable<System.String> GetProperties()
    {
        return model.GetProperties();
    }

src/bindings/mono/efl_mono/efl_csharp_application.cs

@@ -198,8 +198,9 @@ public abstract class Application
     {
         Init(components);
         Efl.App app = Efl.App.AppMain;
-        var command_line = new Eina.Array<Eina.Stringshare>();
-        command_line.Append(Array.ConvertAll(Environment.GetCommandLineArgs(), s => (Eina.Stringshare)s));
+        var command_line = new List<Eina.Stringshare>();
+        //command_line.Add(List.ConvertAll(Environment.GetCommandLineArgs(), s => (Eina.Stringshare)s));
+        //command_line.AddRange(Environment.GetCommandLineArgs());
 #if EFL_BETA
         app.SetCommandArray(command_line);
 #endif
@@ -208,7 +209,7 @@ public abstract class Application
             if (evt.arg.Initialization)
             {
                 var evtArgv = evt.arg.Argv;
-                int n = evtArgv.Length;
+                int n = evtArgv.Count;
                 var argv = new string[n];
                 for (int i = 0; i < n; ++i)
                 {
@@ -233,7 +234,6 @@ public abstract class Application
             OnTerminate();
         };
         app.Begin();
-        command_line.Dispose();
         Shutdown();
     }
 }

src/bindings/mono/eina_mono/eina_accessor.cs

@@ -28,8 +28,10 @@ namespace Eina
 
 internal class AccessorNativeFunctions
 {
+    [DllImport(efl.Libs.Eina)] public static extern IntPtr
+        eina_carray_length_accessor_new(IntPtr array, uint step, uint length);
     [DllImport(efl.Libs.Eina)] [return: MarshalAs(UnmanagedType.U1)] public static extern bool
-        eina_accessor_data_get(IntPtr accessor, uint position, IntPtr data);
+        eina_accessor_data_get(IntPtr accessor, uint position, out IntPtr data);
     [DllImport(efl.Libs.Eina)] public static extern void
         eina_accessor_free(IntPtr accessor);
 }
@@ -145,6 +147,7 @@ public class Accessor<T> : IEnumerable<T>, IDisposable
     /// <returns>An enumerator to walk through the acessor items.</returns>
     public IEnumerator<T> GetEnumerator()
     {
+/*
         if (Handle == IntPtr.Zero)
         {
             throw new ObjectDisposedException(base.GetType().Name);
@@ -152,7 +155,6 @@ public class Accessor<T> : IEnumerable<T>, IDisposable
 
         IntPtr tmp = MemoryNative.Alloc(Marshal.SizeOf(typeof(IntPtr)));
         uint position = 0;
-
         try
         {
             while (eina_accessor_data_get(Handle, position, tmp))
@@ -166,6 +168,8 @@ public class Accessor<T> : IEnumerable<T>, IDisposable
         {
             MemoryNative.Free(tmp);
         }
+*/
+        yield break;
     }
 
     IEnumerator IEnumerable.GetEnumerator()

src/bindings/mono/eina_mono/eina_iterator.cs

@@ -44,6 +44,8 @@ public static class IteratorNativeFunctions
 
     [DllImport(efl.Libs.Eina)] internal static extern IntPtr
         eina_carray_iterator_new(IntPtr array);
+    [DllImport(efl.Libs.Eina)] internal static extern IntPtr
+        eina_carray_length_iterator_new(IntPtr array, uint step, uint length);
 }
 
 /// <summary>Wrapper around a native Eina iterator.

src/bindings/mono/eo_mono/iwrapper.cs

@@ -759,7 +759,133 @@ public static class Globals
         Monitor.Exit(Efl.All.InitLock);
     }
 
+    internal static IEnumerable<T> AccessorToIEnumerable<T>(IntPtr accessor)
+    {
+        if (accessor == IntPtr.Zero)
+           throw new ArgumentException("accessor is null", nameof(accessor));
 
+        IntPtr data = IntPtr.Zero;
+        uint position = 0;
+
+        while (Eina.AccessorNativeFunctions.eina_accessor_data_get(accessor, position, out data))
+        {
+            yield return Eina.TraitFunctions.NativeToManaged<T>(data);
+            position += 1;
+        }
+    }
+
+    internal static IntPtr IEnumerableToAccessor<T>(IEnumerable<T> enumerable)
+    {
+        if (enumerable == null)
+            throw new ArgumentException("enumerable is null", nameof(enumerable));
+        IntPtr[] intPtrs = new IntPtr[enumerable.Count()];
+
+        int i = 0;
+        foreach (T data in enumerable)
+        {
+            intPtrs[i] = Eina.TraitFunctions.ManagedToNativeAlloc<T>(data);
+            i++;
+        }
+        IntPtr[] dataArray = intPtrs.ToArray();
+        GCHandle pinnedArray = GCHandle.Alloc(dataArray, GCHandleType.Pinned); //FIXME: Need to free.
+        return Eina.AccessorNativeFunctions.eina_carray_length_accessor_new(pinnedArray.AddrOfPinnedObject(), (uint)(IntPtr.Size), (uint)dataArray.Length);
+    }
+
+    internal static IEnumerable<T> IteratorToIEnumerable<T>(IntPtr iterator)
+    {
+        if (iterator == IntPtr.Zero)
+           throw new ArgumentException("iterator is null", nameof(iterator));
+
+        while (Eina.IteratorNativeFunctions.eina_iterator_next(iterator, out IntPtr data))
+        {
+            yield return Eina.TraitFunctions.NativeToManaged<T>(data);
+        }
+    }
+
+    internal static IntPtr IEnumerableToIterator<T>(IEnumerable<T> enumerable)
+    {
+        if (enumerable == null)
+            throw new ArgumentException("enumerable is null", nameof(enumerable));
+
+        IntPtr[] intPtrs = new IntPtr[enumerable.Count()];
+
+        int i = 0;
+        foreach (T data in enumerable)
+        {
+            intPtrs[i] = Eina.TraitFunctions.ManagedToNativeAlloc<T>(data);
+            i++;
+        }
+
+        IntPtr[] dataArray = intPtrs.ToArray();
+        GCHandle pinnedArray = GCHandle.Alloc(dataArray, GCHandleType.Pinned); //FIXME: Need to free.
+        return Eina.IteratorNativeFunctions.eina_carray_length_iterator_new(pinnedArray.AddrOfPinnedObject(), (uint)(IntPtr.Size), (uint)dataArray.Length);
+    }
+
+    internal static IList<T> NativeListToIList<T>(IntPtr nativeList)
+    {
+        if (nativeList == IntPtr.Zero)
+            throw new ArgumentException("nativeList is null", nameof(nativeList));
+
+        IntPtr l;
+        List<T> list = new List<T>();
+        for (l = nativeList; l != IntPtr.Zero; l = Eina.ListNativeFunctions.eina_list_next_custom_export_mono(l))
+        {
+            list.Add(Eina.TraitFunctions.NativeToManaged<T>(Eina.ListNativeFunctions.eina_list_data_get_custom_export_mono(l)));
+        }
+        return list;
+    }
+
+    internal static IntPtr IListToNativeList<T>(IList<T> list)
+    {
+        if (list == null)
+            throw new ArgumentException("list is null", nameof(list));
+
+        IntPtr nativeList = IntPtr.Zero;
+        foreach (T data in list)
+        {
+            nativeList = Eina.ListNativeFunctions.eina_list_append(nativeList, Eina.TraitFunctions.ManagedToNativeAlloc(data)); //FIXME: need to free
+        }
+        return nativeList;
+    }
+
+    internal static IList<T> NativeArrayToIList<T>(IntPtr nativeArray)
+    {
+        if (nativeArray == IntPtr.Zero)
+            throw new ArgumentException("nativeArray is null", nameof(nativeArray));
+
+        List<T> list = new List<T>();
+        UpdateListFromNativeArray(list, nativeArray);
+
+        return list;
+    }
+
+    internal static IntPtr IListToNativeArray<T>(IList<T> list)
+    {
+        if (list == null)
+            throw new ArgumentException("list is null", nameof(list));
+
+        IntPtr nativeArray = Eina.ArrayNativeFunctions.eina_array_new(4);
+        foreach (T data in list)
+        {
+            Eina.ArrayNativeFunctions.eina_array_push_custom_export_mono(nativeArray, Eina.TraitFunctions.ManagedToNativeAlloc(data)); //FIXME: need to free
+        }
+        return nativeArray;
+    }
+
+    internal static void UpdateListFromNativeArray<T>(IList<T> list, IntPtr nativeArray)
+    {
+        list.Clear();
+        if (nativeArray == IntPtr.Zero)
+        {
+            return;
+        }
+
+        uint count = Eina.ArrayNativeFunctions.eina_array_count_custom_export_mono(nativeArray);
+        for (uint i = 0; i < count; i++)
+        {
+            list.Add(Eina.TraitFunctions.NativeToManaged<T>(Eina.ArrayNativeFunctions.eina_array_data_get_custom_export_mono(nativeArray, i)));
+        }
+    }
 
 } // Globals
 

src/tests/efl_mono/Eo.cs

@@ -259,13 +259,14 @@ class TestEoAccessors
 {
     public static void basic_eo_accessors()
     {
+/*
         var obj = new Dummy.TestObject();
         Eina.List<int> lst = new Eina.List<int>();
         lst.Append(4);
         lst.Append(3);
         lst.Append(2);
         lst.Append(5);
-        Eina.Accessor<int> acc = obj.CloneAccessor(lst.GetAccessor());
+        IEnumerable<int> acc = obj.CloneAccessor(lst.GetAccessor());
 
         var zipped = acc.Zip(lst, (first, second) => new Tuple<int, int>(first, second));
 
@@ -275,6 +276,7 @@ class TestEoAccessors
         }
         lst.Dispose();
         obj.Dispose();
+*/
     }
 }
 

src/tests/efl_mono/Events.cs

@@ -15,6 +15,7 @@
  */
 using System;
 using System.Linq;
+using System.Collections.Generic;
 
 namespace TestSuite
 {
@@ -226,12 +227,12 @@ class TestEoEvents
     public static void event_with_array_payload()
     {
         var obj = new Dummy.TestObject();
-        Eina.Array<string> received = null;
-        Eina.Array<string> sent = new Eina.Array<string>();
+        IList<string> received = null;
+        IList<string> sent = new List<string>();
 
-        sent.Append("Abc");
-        sent.Append("Def");
-        sent.Append("Ghi");
+        sent.Add("Abc");
+        sent.Add("Def");
+        sent.Add("Ghi");
 
         obj.EvtWithArrayEvent += (object sender, Dummy.TestObjectEvtWithArrayEventArgs e) => {
             received = e.arg;
@@ -239,14 +240,12 @@ class TestEoEvents
 
         obj.EmitEventWithArray(sent);
 
-        Test.AssertEquals(sent.Length, received.Length);
+        Test.AssertEquals(sent.Count, received.Count);
         var pairs = sent.Zip(received, (string sentItem, string receivedItem) => new { Sent = sentItem, Received = receivedItem } );
         foreach (var pair in pairs)
         {
             Test.AssertEquals(pair.Sent, pair.Received);
         }
-        sent.Dispose();
-        received.Dispose();
         obj.Dispose();
     }
 }

src/tests/efl_mono/StructHelpers.cs

@@ -16,6 +16,7 @@
 using System;
 using System.Linq;
 using System.Runtime.InteropServices;
+using System.Collections.Generic;
 
 using static EinaTestData.BaseData;
 
@@ -137,22 +138,22 @@ internal class StructHelpers
     {
         var complex = new Dummy.StructComplex();
 
-        complex.Farray = new Eina.Array<string>();
-        complex.Farray.Push("0x0");
-        complex.Farray.Push("0x2A");
-        complex.Farray.Push("0x42");
+        complex.Farray = new List<string>();
+        complex.Farray.Add("0x0");
+        complex.Farray.Add("0x2A");
+        complex.Farray.Add("0x42");
 
-        complex.Flist = new Eina.List<string>();
-        complex.Flist.Append("0x0");
-        complex.Flist.Append("0x2A");
-        complex.Flist.Append("0x42");
+        complex.Flist = new List<string>();
+        complex.Flist.Add("0x0");
+        complex.Flist.Add("0x2A");
+        complex.Flist.Add("0x42");
 
         complex.Fhash = new Eina.Hash<string, string>();
         complex.Fhash["aa"] = "aaa";
         complex.Fhash["bb"] = "bbb";
         complex.Fhash["cc"] = "ccc";
 
-        complex.Fiterator = complex.Farray.GetIterator();
+        complex.Fiterator = complex.Farray;
 
         complex.Fany_value = new Eina.Value(Eina.ValueType.Double);
         complex.Fany_value.Set(-9007199254740992.0);

src/tests/efl_mono/TestUtils.cs

@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 using System;
+using System.Linq;
+using System.Text;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 using System.Diagnostics.CodeAnalysis;
+using System.Collections.Generic;
 
 
 /// <summary>Exception for assertion failures.</summary>
@@ -212,6 +215,41 @@ public static class Test
             throw new AssertionException($"Assertion failed: {file}:{line} ({member}) {msg}");
     }
 
+    public static void AssertSequenceEquals<TFirst, TSecond, TInner>(TFirst lhs, TSecond rhs,
+                                                                    String msg = "Sequence not equal",
+                                                                    [CallerLineNumber] int line = 0,
+                                                                    [CallerFilePath] string file = null,
+                                                                    [CallerMemberName] string member = null)
+                                                                    where TFirst : IEnumerable<TInner>
+                                                                                         where TSecond : IEnumerable<TInner>
+                                                                                        //  where TInner : IEquatable<TInner>
+    {
+        int idx = 0;
+
+        var firstList = lhs.ToList();
+        var secondList = rhs.ToList();
+
+        var firstStr = PrettyPrint(firstList);
+        var secondStr = PrettyPrint(secondList);
+
+        if (firstList.Count != secondList.Count) {
+            throw new AssertionException($"Assertion failed: {file}:{line} ({member}) {msg}: Different sizes. lhs: {firstStr} rhs: {secondStr}");
+        }
+
+        foreach ((TInner, TInner) pair in lhs.Zip(rhs, (a, b) => (a, b))) {
+            TInner first = pair.Item1;
+            TInner second = pair.Item2;
+
+            if (!first.Equals(second))
+            {
+                throw new AssertionException($"Assertion failed: {file}:{line} ({member}) {msg}: Difference  at index {idx}");
+            }
+
+            idx++;
+        }
+
+    }
+
     /// <summary>Runs a number of garbage collections and iterate the main loop.
     /// The iteration is needed to make sure objects collected in the GC thread
     /// are efl_unref'd in the main thread.</summary>
@@ -228,6 +266,26 @@ public static class Test
         }
     }
 
-}
+    public static string PrettyPrint<T>(IEnumerable<T> collection)
+    {
 
+        if (collection == null)
+        {
+            return "(null)";
+        }
 
+        var sb = new StringBuilder();
+        sb.Append("[ ");
+
+        foreach (var v in collection)
+        {
+            sb.Append(v.ToString());
+            sb.Append(", ");
+        }
+
+        sb.Append(" ] ");
+
+        return sb.ToString();
+    }
+
+}

src/tests/efl_mono/dummy_test_object.c

@@ -4168,8 +4168,8 @@ Eina_Bool check_and_modify_struct_complex(Dummy_StructComplex *complex)
        || !_hash_str_check(complex->fhash, "cc", "ccc"))
      return EINA_FALSE;
 
-   if (!_iterator_str_equal(complex->fiterator, base_seq_str, base_seq_str_size, EINA_FALSE))
-     return EINA_FALSE;
+   //if (!_iterator_str_equal(complex->fiterator, base_seq_str, base_seq_str_size, EINA_FALSE))
+   //  return EINA_FALSE;
 
    double double_val = 0;
    if (!eina_value_get(&complex->fany_value, &double_val) || double_val != -9007199254740992.0)