eolian_cxx: Fix "dreaded diamond" inheritance problem for C++ wrappers

Solved diamond inheritance problem by completely removing inheritance in
the abstract class.
All ancestors are inherited directly in the concrete class.
The algorithm that list the ancestors also avoid repetition.

Now concrete classes define methods too. This helps referring the correct
method directly by the object type (when there are methods with the same
name).

Moved the declaration and definition of constructor methods to the concrete
class, since they should not be used in derived classes.

Updated example that call "color_set".
With this model, if two ancestor classes have a method with the same name,
to call one of them from a derived class you must write the scoped name of
the member function in the wrapper.
In this case, either Evas.Object and Evas.SmartObject have a property
named "color".

Added "from_global" option to the full_name grammar too.

diff --git a/src/bin/eolian_cxx/convert.cc b/src/bin/eolian_cxx/convert.cc
index 8f5cec8..2fa45b5 100644 (file)
--- a/src/bin/eolian_cxx/convert.cc
+++ b/src/bin/eolian_cxx/convert.cc
@@ -1,5 +1,6 @@
 
 #include <vector>
+#include <set>
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
@@ -23,8 +24,11 @@ namespace eolian_cxx {
 extern efl::eina::log_domain domain;
 
 void
-remove_repeated_base(const char* klass_name, efl::eolian::parents_container_type& cont)
+add_parent_recursive(const char* klass_name, std::set<std::string>& parents)
 {
+   if (!klass_name)
+     return;
+
    Eolian_Class const* klass = ::eolian_class_get_by_name(klass_name);
    if (!klass)
      {
@@ -32,20 +36,14 @@ remove_repeated_base(const char* klass_name, efl::eolian::parents_container_type
         return;
      }
 
+   parents.insert(class_format_cxx(safe_lower(klass_name)));
+
    Eina_Iterator* inheritances = ::eolian_class_inherits_get(klass);
    void* curr = 0;
 
    EINA_ITERATOR_FOREACH(inheritances, curr)
      {
-        if (!curr)
-          continue;
-
-        const char* parent = static_cast<const char*>(curr);
-        cont.erase(
-          std::remove(cont.begin(), cont.end(), safe_lower(class_format_cxx(parent)))
-          , cont.end());
-
-        remove_repeated_base(parent, cont);
+        add_parent_recursive(static_cast<const char*>(curr), parents);
      }
    eina_iterator_free(inheritances);
 }
@@ -184,23 +182,15 @@ convert_eolian_inheritances(efl::eolian::eo_class& cls, Eolian_Class const& klas
      ::eolian_class_inherits_get(&klass);
    void *curr;
 
-   EINA_ITERATOR_FOREACH(inheritances, curr)
-     {
-        std::string parent = safe_lower(static_cast<const char*>(curr));
-        cls.parents.push_back(class_format_cxx(parent));
-     }
-   eina_iterator_free(inheritances);
+   std::set<std::string> parents;
 
-   if (cls.parents.empty())
-     return;
-
-   inheritances = ::eolian_class_inherits_get(&klass);
    EINA_ITERATOR_FOREACH(inheritances, curr)
      {
-        if (curr)
-          remove_repeated_base(static_cast<const char*>(curr), cls.parents);
+        add_parent_recursive(static_cast<const char*>(curr), parents);
      }
    eina_iterator_free(inheritances);
+
+   cls.parents.assign(parents.begin(), parents.end());
 }
 
 void

diff --git a/src/examples/eolian_cxx/eolian_cxx_complex_types_01.cc b/src/examples/eolian_cxx/eolian_cxx_complex_types_01.cc
index 264ece2..8dd5d29 100644 (file)
--- a/src/examples/eolian_cxx/eolian_cxx_complex_types_01.cc
+++ b/src/examples/eolian_cxx/eolian_cxx_complex_types_01.cc
@@ -74,7 +74,7 @@ example_complex_types()
 
    efl::evas::grid grid(efl::eo::parent = canvas);
    grid.position_set(0, 0);
-   grid.color_set(0, 0, 0, 255);
+   grid.object_smart::color_set(0, 0, 0, 255);
    grid.size_set(5, 5);
    grid.visibility_set(true);
 

diff --git a/src/lib/eolian_cxx/grammar/eo_class_constructors_generator.hh b/src/lib/eolian_cxx/grammar/eo_class_constructors_generator.hh
index 9e1ab58..9ffed75 100644 (file)
--- a/src/lib/eolian_cxx/grammar/eo_class_constructors_generator.hh
+++ b/src/lib/eolian_cxx/grammar/eo_class_constructors_generator.hh
@@ -46,8 +46,7 @@ operator<<(std::ostream& out, class_inheritance const& x)
      last = cls.parents.cend();
    for (it = first; it != last; ++it)
      {
-        out << tab(2) << (it == first ? ": " : ", ")
-            << "::" << abstract_namespace << "::" << *it << endl;
+        out << tab(2) << ", ::" << abstract_namespace << "::" << *it << endl;
      }
    return out;
 }
@@ -241,9 +240,9 @@ operator<<(std::ostream& out, constructor_method_function_definitions const& x)
           }
 
         out << template_parameters_declaration(c.params, 0)
-            << "inline " << abstract_full_name(x._cls)
+            << "inline " << full_name(x._cls)
             << "::" << constructor_functor_type_decl(c) << " "
-            << abstract_full_name(x._cls, false) << "::" << c.name << "("
+            << full_name(x._cls, false) << "::" << c.name << "("
             << parameters_declaration(c.params) << ") const" << endl
             << "{" << endl
             << tab(1) << "return " << constructor_functor_type_decl(c) << "("

diff --git a/src/lib/eolian_cxx/grammar/eo_class_functions_generator.hh b/src/lib/eolian_cxx/grammar/eo_class_functions_generator.hh
index f375fd7..56b450b 100644 (file)
--- a/src/lib/eolian_cxx/grammar/eo_class_functions_generator.hh
+++ b/src/lib/eolian_cxx/grammar/eo_class_functions_generator.hh
@@ -61,8 +61,9 @@ struct function_definition
 {
    eo_class const& _cls;
    eo_function const& _func;
-   function_definition(eo_class const& cls, eo_function const& func)
-     : _cls(cls), _func(func)
+   bool _concrete;
+   function_definition(eo_class const& cls, eo_function const& func, bool concrete)
+     : _cls(cls), _func(func), _concrete(concrete)
    {}
 };
 
@@ -74,8 +75,14 @@ operator<<(std::ostream& out, function_definition const& x)
    bool is_static = function_is_static(func);
 
    out << template_parameters_declaration(func.params, 0)
-       << "inline " << reinterpret_type(func.ret) << " "
-       << abstract_full_name(x._cls, false) << "::" << func.name << "("
+       << "inline " << reinterpret_type(func.ret) << " ";
+
+   if (x._concrete)
+     out << full_name(x._cls, false);
+   else
+     out << abstract_full_name(x._cls, false);
+
+   out << "::" << func.name << "("
        << parameters_declaration(func.params)
        << (is_static ? ")" : ") const") << endl
        << "{" << endl;
@@ -121,8 +128,10 @@ operator<<(std::ostream& out, function_declarations const& x)
 struct function_definitions
 {
    eo_class const& _cls;
-   function_definitions(eo_class const& cls)
+   bool _concrete;
+   function_definitions(eo_class const& cls, bool concrete)
      : _cls(cls)
+     , _concrete(concrete)
    {}
 };
 
@@ -131,7 +140,7 @@ operator<<(std::ostream& out, function_definitions const& x)
 {
    for (eo_function const& f : x._cls.functions)
      {
-        out << function_definition(x._cls, f) << endl;
+        out << function_definition(x._cls, f, x._concrete) << endl;
      }
    return out;
 }

diff --git a/src/lib/eolian_cxx/grammar/eo_class_generator.hh b/src/lib/eolian_cxx/grammar/eo_class_generator.hh
index f54485c..18d2e71 100644 (file)
--- a/src/lib/eolian_cxx/grammar/eo_class_generator.hh
+++ b/src/lib/eolian_cxx/grammar/eo_class_generator.hh
@@ -105,10 +105,7 @@ eo_class_generator(std::ostream& out, eo_class const& cls)
        << namespace_head(cls)
        << comment(cls.comment)
        << "struct " << cls.name << endl
-       << class_inheritance(cls)
        << '{' << endl
-       << functors_constructor_methods(cls)
-       << constructor_method_function_declarations(cls)
        << function_declarations(cls)
        << events(cls)
        << eo_class_getter(cls)
@@ -120,22 +117,29 @@ eo_class_generator(std::ostream& out, eo_class const& cls)
        << "}" << endl << endl
        << namespace_head(cls)
        << "struct " << cls.name << endl
-       << tab(2) << ": " << abstract_full_name(cls) << endl
-       << tab(2) << ", ::efl::eo::concrete" << endl
+       << tab(2) << ": ::efl::eo::concrete" << endl
+       << class_inheritance(cls)
        << '{' << endl
+       << functors_constructor_methods(cls)
        << constructor_with_constructor_methods(cls)
        << constructor_eo(cls)
        << copy_constructor(cls)
        << destructor(cls)
+       << constructor_method_function_declarations(cls)
+       << function_declarations(cls)
+       << events(cls)
+       << eo_class_getter(cls)
         << "private:" << endl
        << function_call_constructor_methods(cls)
+       << tab(2) << "Eo* _concrete_eo_ptr() const { return _eo_ptr(); }" << endl
        << "};" << endl << endl
        << "static_assert(sizeof(" << full_name(cls) << ") == sizeof(Eo*), \"\");" << endl
        << "static_assert(std::is_standard_layout<" << full_name(cls) << ">::value, \"\");" << endl
        << endl
        << namespace_tail(cls)
        << constructor_method_function_definitions(cls)
-       << function_definitions(cls)
+       << function_definitions(cls, true)
+       << function_definitions(cls, false)
        << class_implicit_conversion_definition(cls);
 }
 

diff --git a/src/lib/eolian_cxx/grammar/type_generator.hh b/src/lib/eolian_cxx/grammar/type_generator.hh
index a476205..2dc6681 100644 (file)
--- a/src/lib/eolian_cxx/grammar/type_generator.hh
+++ b/src/lib/eolian_cxx/grammar/type_generator.hh
@@ -15,15 +15,19 @@ using std::endl;
 struct full_name
 {
    eo_class const& _cls;
-   full_name(eo_class const& cls) : _cls(cls) {}
+   bool _from_global;
+   full_name(eo_class const& cls, bool from_global = true)
+     : _cls(cls), _from_global(from_global) {}
 };
 
 inline std::ostream&
 operator<<(std::ostream& out, full_name const& x)
 {
+   if (x._from_global)
+     out << "::";
    if(!x._cls.name_space.empty())
-     out << "::" << x._cls.name_space;
-   return out << "::" << x._cls.name;
+     out << x._cls.name_space << "::";
+   return out << x._cls.name;
 }
 
 struct abstract_full_name