Eolian: modify API to allow future scalability

Until now, the functions giving access to class information were taking
the class name as parameter.
Except the fact that we needed to search into a hash table for the internal
class structure, no flexibility is possible.

This change consists in modifying most of the APIs using the class name
with a new Eolian_Class type and adapt the code of the C and C++
generators accordingly.

19 files changed, 526 insertions, 515 deletions

diff --git a/src/bin/eolian/common_funcs.c b/src/bin/eolian/common_funcs.c
index 311228a871..e75e5f6653 100644
--- a/src/bin/eolian/common_funcs.c
+++ b/src/bin/eolian/common_funcs.c
@@ -23,8 +23,9 @@ _class_func_names_fill(const char *classname, const char *funcname)
         eina_str_tolower(&p);
 
         /* eo_prefix */
-        if (eolian_class_exists(classname))
-           eo_prefix = eolian_class_eo_prefix_get(classname);
+        Eolian_Class class = eolian_class_find_by_name(classname);
+        if (class)
+           eo_prefix = eolian_class_eo_prefix_get(class);
         if (!eo_prefix) eo_prefix = classname;
         strncpy(current_eo_prefix_lower, eo_prefix, sizeof(current_eo_prefix_lower) - 1);
         p = current_eo_prefix_lower;
@@ -42,7 +43,7 @@ _class_func_names_fill(const char *classname, const char *funcname)
 }
 
 void
-_template_fill(Eina_Strbuf *buf, const char* templ, const char* classname, const char *funcname, Eina_Bool reset)
+_template_fill(Eina_Strbuf *buf, const char *templ, const char *classname, const char *funcname, Eina_Bool reset)
 {
    _class_func_names_fill(classname, funcname);
    if (buf)
diff --git a/src/bin/eolian/common_funcs.h b/src/bin/eolian/common_funcs.h
index ace92e6fca..1901c3b5cb 100644
--- a/src/bin/eolian/common_funcs.h
+++ b/src/bin/eolian/common_funcs.h
@@ -32,7 +32,7 @@ extern int _eolian_gen_log_dom;
 #endif
 #define CRIT(...) EINA_LOG_DOM_CRIT(_eolian_gen_log_dom, __VA_ARGS__)
 
-void _template_fill(Eina_Strbuf *buf, const char* templ, const char* classname, const char *funcname, Eina_Bool reset);
+void _template_fill(Eina_Strbuf *buf, const char *templ, const char *classname, const char *funcname, Eina_Bool reset);
 
 char *_nextline(char *str, unsigned int lines);
 
diff --git a/src/bin/eolian/eo1_generator.c b/src/bin/eolian/eo1_generator.c
index 7570842443..bae93c6502 100644
--- a/src/bin/eolian/eo1_generator.c
+++ b/src/bin/eolian/eo1_generator.c
@@ -93,7 +93,7 @@ tmpl_eo_retdesc[] =" * @return %s\n";
 #endif
 
 static Eina_Bool
-eo_fundef_generate(const char *classname, Eolian_Function func, Eolian_Function_Type ftype, Eina_Strbuf *functext)
+eo_fundef_generate(const Eolian_Class class, Eolian_Function func, Eolian_Function_Type ftype, Eina_Strbuf *functext)
 {
    const char *str_dir[] = {"in", "out", "inout"};
    const Eina_List *l;
@@ -132,8 +132,8 @@ eo_fundef_generate(const char *classname, Eolian_Function func, Eolian_Function_
    Eina_Strbuf *str_func = eina_strbuf_new();
    if (scope == EOLIAN_SCOPE_PROTECTED)
       eina_strbuf_append_printf(str_func, "#ifdef %s_PROTECTED\n", capclass);
-   _template_fill(str_func, tmpl_eo_funcdef_doxygen, classname, funcname, EINA_FALSE);
-   _template_fill(str_func, tmpl_eo_funcdef, classname, funcname, EINA_FALSE);
+   _template_fill(str_func, tmpl_eo_funcdef_doxygen, eolian_class_name_get(class), funcname, EINA_FALSE);
+   _template_fill(str_func, tmpl_eo_funcdef, eolian_class_name_get(class), funcname, EINA_FALSE);
    if (scope == EOLIAN_SCOPE_PROTECTED)
       eina_strbuf_append_printf(str_func, "#endif\n");
    eina_strbuf_append_printf(str_func, "\n");
@@ -233,23 +233,16 @@ eo_fundef_generate(const char *classname, Eolian_Function func, Eolian_Function_
 }
 
 Eina_Bool
-eo_header_generate(const char *classname, Eina_Strbuf *buf)
+eo_header_generate(const Eolian_Class class, Eina_Strbuf *buf)
 {
    const Eolian_Function_Type ftype_order[] = {EOLIAN_CTOR, EOLIAN_PROPERTY, EOLIAN_METHOD};
    const Eina_List *l;
    void *data;
    char *tmpstr = malloc(0x1FF);
    Eina_Strbuf * str_hdr = eina_strbuf_new();
+   const char *classname = eolian_class_name_get(class);
 
-   if (!eolian_class_exists(classname))
-     {
-        ERR ("Class \"%s\" not found in database", classname);
-        free(tmpstr);
-        eina_strbuf_free(str_hdr);
-        return EINA_FALSE;
-     }
-
-   const char *desc = eolian_class_description_get(classname);
+   const char *desc = eolian_class_description_get(class);
    Eina_Strbuf *linedesc = eina_strbuf_new();
    eina_strbuf_append(linedesc, "/**\n");
    if (desc)
@@ -274,7 +267,7 @@ eo_header_generate(const char *classname, Eina_Strbuf *buf)
    Eina_Strbuf *tmpbuf = eina_strbuf_new();
 
    Eolian_Event event;
-   EINA_LIST_FOREACH(eolian_class_events_list_get(classname), l, event)
+   EINA_LIST_FOREACH(eolian_class_events_list_get(class), l, event)
      {
         const char *evname = NULL;
         const char *evdesc = NULL;
@@ -296,7 +289,7 @@ eo_header_generate(const char *classname, Eina_Strbuf *buf)
 
    int i;
    for (i = 0; i < 3; i++)
-      EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, ftype_order[i]), l, data)
+      EINA_LIST_FOREACH(eolian_class_functions_list_get(class, ftype_order[i]), l, data)
         {
            const Eolian_Function_Type ftype = eolian_function_type_get((Eolian_Function)data);
            const char *funcname = eolian_function_name_get((Eolian_Function)data);
@@ -306,19 +299,19 @@ eo_header_generate(const char *classname, Eina_Strbuf *buf)
            if (!prop_read && !prop_write)
              {
                 _template_fill(str_subid, tmpl_eo_subid, classname, funcname, EINA_FALSE);
-                eo_fundef_generate(classname, (Eolian_Function)data, EOLIAN_UNRESOLVED, str_hdr);
+                eo_fundef_generate(class, (Eolian_Function)data, EOLIAN_UNRESOLVED, str_hdr);
              }
            if (prop_write)
              {
                 sprintf(tmpstr, "%s_set", funcname);
                 _template_fill(str_subid, tmpl_eo_subid, classname, tmpstr, EINA_FALSE);
-                eo_fundef_generate(classname, (Eolian_Function)data, EOLIAN_PROP_SET, str_hdr);
+                eo_fundef_generate(class, (Eolian_Function)data, EOLIAN_PROP_SET, str_hdr);
              }
            if (prop_read)
              {
                 sprintf(tmpstr, "%s_get", funcname);
                 _template_fill(str_subid, tmpl_eo_subid, classname, tmpstr, EINA_FALSE);
-                eo_fundef_generate(classname, (Eolian_Function)data, EOLIAN_PROP_GET, str_hdr);
+                eo_fundef_generate(class, (Eolian_Function)data, EOLIAN_PROP_GET, str_hdr);
              }
            eina_strbuf_replace_all(str_subid, "@#EOPREFIX", current_eo_prefix_upper);
         }
@@ -340,7 +333,7 @@ eo_header_generate(const char *classname, Eina_Strbuf *buf)
 }
 
 static Eina_Bool
-eo_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Function_Type ftype, Eina_Strbuf *buf, const char *impl_name)
+eo_bind_func_generate(const Eolian_Class class, Eolian_Function funcid, Eolian_Function_Type ftype, Eina_Strbuf *buf, const char *impl_name)
 {
    const char *suffix = "";
    Eina_Bool var_as_ret = EINA_FALSE;
@@ -348,6 +341,7 @@ eo_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Func
    const char *retname = NULL;
    Eina_Bool ret_const = EINA_FALSE;
    Eina_Bool add_star = EINA_FALSE;
+   const char *classname = eolian_class_name_get(class);
 
    Eina_Bool need_implementation = EINA_TRUE;
    if (!impl_name && eolian_function_is_virtual_pure(funcid, ftype)) need_implementation = EINA_FALSE;
@@ -467,7 +461,7 @@ eo_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Func
    if (need_implementation)
      {
         eina_strbuf_replace_all(fbody, "@#full_params", eina_strbuf_string_get(full_params));
-        const char *data_type = eolian_class_data_type_get(classname);
+        const char *data_type = eolian_class_data_type_get(class);
         if (data_type && !strcmp(data_type, "null"))
            eina_strbuf_replace_all(fbody, "@#Datatype_Data", "void");
         else
@@ -491,12 +485,12 @@ eo_bind_func_generate(const char *classname, Eolian_Function funcid, Eolian_Func
 }
 
 static Eina_Bool
-eo_func_desc_generate(const char *class_name, const char *impl_name, const char *func_name, Eina_Strbuf *buf)
+eo_func_desc_generate(const Eolian_Class class, const char *impl_name, const char *func_name, Eina_Strbuf *buf)
 {
    if (impl_name)
       _class_func_names_fill(impl_name, func_name);
    else
-      _class_func_names_fill(class_name, func_name);
+      _class_func_names_fill(eolian_class_name_get(class), func_name);
    eina_strbuf_reset(buf);
    eina_strbuf_append_printf(buf,
          "\n        EO_OP_FUNC(%s_ID(%s_SUB_ID_%s), _eo_obj_%s%s%s_%s),",
@@ -507,14 +501,14 @@ eo_func_desc_generate(const char *class_name, const char *impl_name, const char
 }
 
 static Eina_Bool
-eo_op_desc_generate(const char *classname, Eolian_Function fid, Eolian_Function_Type ftype,
+eo_op_desc_generate(const Eolian_Class class, Eolian_Function fid, Eolian_Function_Type ftype,
       const char *desc, Eina_Strbuf *buf)
 {
    const char *funcname = eolian_function_name_get(fid);
    const char *suffix = "";
 
    eina_strbuf_reset(buf);
-   _class_func_names_fill(classname, funcname);
+   _class_func_names_fill(eolian_class_name_get(class), funcname);
    if (ftype == EOLIAN_PROP_GET) suffix = "_get";
    if (ftype == EOLIAN_PROP_SET) suffix = "_set";
    Eina_Bool is_virtual_pure = eolian_function_is_virtual_pure(fid, ftype);
@@ -528,7 +522,7 @@ eo_op_desc_generate(const char *classname, Eolian_Function fid, Eolian_Function_
 }
 
 static Eina_Bool
-eo_source_beginning_generate(const char *classname, Eina_Strbuf *buf)
+eo_source_beginning_generate(const Eolian_Class class, Eina_Strbuf *buf)
 {
    const Eina_List *itr;
 
@@ -536,7 +530,7 @@ eo_source_beginning_generate(const char *classname, Eina_Strbuf *buf)
    Eina_Strbuf *str_ev = eina_strbuf_new();
 
    Eolian_Event event;
-   EINA_LIST_FOREACH(eolian_class_events_list_get(classname), itr, event)
+   EINA_LIST_FOREACH(eolian_class_events_list_get(class), itr, event)
      {
         const char *evname;
         const char *evdesc;
@@ -544,7 +538,7 @@ eo_source_beginning_generate(const char *classname, Eina_Strbuf *buf)
 
         eolian_class_event_information_get(event, &evname, NULL, &evdesc);
         evdesc_line1 = _source_desc_get(evdesc);
-        _template_fill(str_ev, "@#CLASS_EVENT_@#FUNC", classname, evname, EINA_TRUE);
+        _template_fill(str_ev, "@#CLASS_EVENT_@#FUNC", eolian_class_name_get(class), evname, EINA_TRUE);
         eina_strbuf_replace_all(str_ev, ",", "_");
 
         eina_strbuf_append_printf(tmpbuf,
@@ -561,14 +555,15 @@ eo_source_beginning_generate(const char *classname, Eina_Strbuf *buf)
 }
 
 static Eina_Bool
-eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
+eo_source_end_generate(const Eolian_Class class, Eina_Strbuf *buf)
 {
    Eina_Bool ret = EINA_FALSE;
    const Eina_List *itr;
    Eolian_Function fn;
+   const char *classname = eolian_class_name_get(class);
 
    const char *str_classtype = NULL;
-   switch(eolian_class_type_get(classname))
+   switch(eolian_class_type_get(class))
     {
       case EOLIAN_CLASS_REGULAR:
         str_classtype = "EO_CLASS_TYPE_REGULAR";
@@ -610,14 +605,14 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
    eina_strbuf_replace_all(str_end, "@#ctor_func", eina_strbuf_string_get(tmpbuf));
 
    eina_strbuf_reset(tmpbuf);
-   if (eolian_class_ctor_enable_get(classname))
+   if (eolian_class_ctor_enable_get(class))
       _template_fill(tmpbuf, "_@#class_class_constructor", classname, "", EINA_TRUE);
    else
       eina_strbuf_append_printf(tmpbuf, "NULL");
    eina_strbuf_replace_all(str_end, "@#ctor_name", eina_strbuf_string_get(tmpbuf));
 
    eina_strbuf_reset(tmpbuf);
-   if (eolian_class_dtor_enable_get(classname))
+   if (eolian_class_dtor_enable_get(class))
      {
         eina_strbuf_replace_all(str_end, "@#dtor_func", eina_strbuf_string_get(tmpbuf));
         eina_strbuf_reset(tmpbuf);
@@ -634,23 +629,23 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
 
    //Implements - TODO one generate func def for all
    Eolian_Implement impl_desc;
-   EINA_LIST_FOREACH(eolian_class_implements_list_get(classname), itr, impl_desc)
+   EINA_LIST_FOREACH(eolian_class_implements_list_get(class), itr, impl_desc)
      {
         const char *funcname;
-        const char *impl_class;
+        const char *impl_classname;
         Eolian_Function_Type ftype;
 
-        eolian_implement_information_get(impl_desc, &impl_class, &funcname, &ftype);
+        eolian_implement_information_get(impl_desc, &impl_classname, &funcname, &ftype);
 
         eina_strbuf_reset(tmpl_impl);
-        _template_fill(str_func, NULL, impl_class, NULL, EINA_FALSE); /* Invoked to set the variables */
+        _template_fill(str_func, NULL, impl_classname, NULL, EINA_FALSE); /* Invoked to set the variables */
         eina_strbuf_append(tmpl_impl, tmpl_eo_func_desc);
         eina_strbuf_replace_all(tmpl_impl, "@#EOPREFIX", current_eo_prefix_upper);
         eina_strbuf_replace_all(tmpl_impl, "@#eoprefix", current_eo_prefix_lower);
 
         char implname[0xFF];
         char *tp = implname;
-        sprintf(implname, "%s_%s", classname, impl_class);
+        sprintf(implname, "%s_%s", classname, impl_classname);
         eina_str_tolower(&tp);
 
         eina_strbuf_replace_all(tmpl_impl, "@#class", implname);
@@ -660,16 +655,17 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
         Eolian_Function in_prop = NULL;
         const Eina_List *itr2;
         Eolian_Function fnid;
-        EINA_LIST_FOREACH(eolian_class_functions_list_get((char *)impl_class, EOLIAN_CTOR), itr2, fnid)
+        Eolian_Class impl_class = eolian_class_find_by_name(impl_classname);
+        EINA_LIST_FOREACH(eolian_class_functions_list_get(impl_class, EOLIAN_CTOR), itr2, fnid)
           if (fnid && !strcmp(eolian_function_name_get(fnid), funcname)) in_meth = fnid;
-        EINA_LIST_FOREACH(eolian_class_functions_list_get((char *)impl_class, EOLIAN_METHOD), itr2, fnid)
+        EINA_LIST_FOREACH(eolian_class_functions_list_get(impl_class, EOLIAN_METHOD), itr2, fnid)
           if (fnid && !strcmp(eolian_function_name_get(fnid), funcname)) in_meth = fnid;
-        EINA_LIST_FOREACH(eolian_class_functions_list_get((char *)impl_class, EOLIAN_PROPERTY), itr2, fnid)
+        EINA_LIST_FOREACH(eolian_class_functions_list_get(impl_class, EOLIAN_PROPERTY), itr2, fnid)
           if (fnid && !strcmp(eolian_function_name_get(fnid), funcname)) in_prop = fnid;
 
         if (!in_meth && !in_prop)
           {
-             ERR ("Failed to generate implementation of %s:%s - missing form super class", impl_class, funcname);
+             ERR ("Failed to generate implementation of %s:%s - missing form super class", impl_classname, funcname);
              goto end;
           }
 
@@ -680,8 +676,8 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
 
         if (in_meth)
           {
-             _template_fill(str_op, tmpl_impl_str, impl_class, funcname, EINA_FALSE);
-              eo_bind_func_generate(classname, in_meth, EOLIAN_UNRESOLVED, str_bodyf, impl_class);
+             _template_fill(str_op, tmpl_impl_str, impl_classname, funcname, EINA_FALSE);
+              eo_bind_func_generate(class, in_meth, EOLIAN_UNRESOLVED, str_bodyf, impl_classname);
              continue;
           }
 
@@ -697,37 +693,37 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
              if (prop_write)
                {
                   sprintf(tmpstr, "%s_set", funcname);
-                  _template_fill(str_op, tmpl_impl_str, impl_class, tmpstr, EINA_FALSE);
-                  eo_bind_func_generate(classname, in_prop, EOLIAN_PROP_SET, str_bodyf, impl_class);
+                  _template_fill(str_op, tmpl_impl_str, impl_classname, tmpstr, EINA_FALSE);
+                  eo_bind_func_generate(class, in_prop, EOLIAN_PROP_SET, str_bodyf, impl_classname);
                }
 
              if (prop_read)
                {
                   sprintf(tmpstr, "%s_get", funcname);
-                  _template_fill(str_op, tmpl_impl_str, impl_class, tmpstr, EINA_FALSE);
-                  eo_bind_func_generate(classname, in_prop, EOLIAN_PROP_GET, str_bodyf, impl_class);
+                  _template_fill(str_op, tmpl_impl_str, impl_classname, tmpstr, EINA_FALSE);
+                  eo_bind_func_generate(class, in_prop, EOLIAN_PROP_GET, str_bodyf, impl_classname);
                }
           }
         eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf));
      }
 
    //Constructors
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, EOLIAN_CTOR), itr, fn)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_CTOR), itr, fn)
      {
         const char *funcname = eolian_function_name_get(fn);
         char *desc = _source_desc_get(eolian_function_description_get(fn, "comment"));
-        eo_op_desc_generate(classname, fn, EOLIAN_CTOR, desc, tmpbuf);
+        eo_op_desc_generate(class, fn, EOLIAN_CTOR, desc, tmpbuf);
         eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf));
         free(desc);
 
-        eo_func_desc_generate(classname, NULL, funcname, tmpbuf);
+        eo_func_desc_generate(class, NULL, funcname, tmpbuf);
         eina_strbuf_append(str_func, eina_strbuf_string_get(tmpbuf));
 
-        eo_bind_func_generate(classname, fn, EOLIAN_UNRESOLVED, str_bodyf, NULL);
+        eo_bind_func_generate(class, fn, EOLIAN_UNRESOLVED, str_bodyf, NULL);
      }
 
    //Properties
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, EOLIAN_PROPERTY), itr, fn)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_PROPERTY), itr, fn)
      {
         const char *funcname = eolian_function_name_get(fn);
         const Eolian_Function_Type ftype = eolian_function_type_get(fn);
@@ -741,12 +737,12 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
              char *desc = _source_desc_get(eolian_function_description_get(fn, "comment_set"));
 
              sprintf(tmpstr, "%s_set", funcname);
-             eo_op_desc_generate(classname, fn, EOLIAN_PROP_SET, desc, tmpbuf);
+             eo_op_desc_generate(class, fn, EOLIAN_PROP_SET, desc, tmpbuf);
              eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf));
              free(desc);
 
              if (!eolian_function_is_virtual_pure(fn, EOLIAN_PROP_SET))
-                eo_func_desc_generate(classname, NULL, tmpstr, tmpbuf);
+                eo_func_desc_generate(class, NULL, tmpstr, tmpbuf);
              else
                 eina_strbuf_reset(tmpbuf);
              eina_strbuf_append(str_func, eina_strbuf_string_get(tmpbuf));
@@ -756,12 +752,12 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
              char *desc = _source_desc_get(eolian_function_description_get(fn, "comment_get"));
 
              sprintf(tmpstr, "%s_get", funcname);
-             eo_op_desc_generate(classname, fn, EOLIAN_PROP_GET, desc, tmpbuf);
+             eo_op_desc_generate(class, fn, EOLIAN_PROP_GET, desc, tmpbuf);
              free(desc);
              eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf));
 
              if (!eolian_function_is_virtual_pure(fn, EOLIAN_PROP_GET))
-                eo_func_desc_generate(classname, NULL, tmpstr, tmpbuf);
+                eo_func_desc_generate(class, NULL, tmpstr, tmpbuf);
              else
                 eina_strbuf_reset(tmpbuf);
              eina_strbuf_append(str_func, eina_strbuf_string_get(tmpbuf));
@@ -769,24 +765,24 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
      }
 
    //Methods
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, EOLIAN_METHOD), itr, fn)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_METHOD), itr, fn)
      {
         const char *funcname = eolian_function_name_get(fn);
 
         char *desc = _source_desc_get(eolian_function_description_get(fn, "comment"));
-        eo_op_desc_generate(classname, fn, EOLIAN_METHOD, desc, tmpbuf);
+        eo_op_desc_generate(class, fn, EOLIAN_METHOD, desc, tmpbuf);
         free(desc);
         eina_strbuf_append(str_op, eina_strbuf_string_get(tmpbuf));
 
         if (!eolian_function_is_virtual_pure(fn, EOLIAN_METHOD))
-           eo_func_desc_generate(classname, NULL, funcname, tmpbuf);
+           eo_func_desc_generate(class, NULL, funcname, tmpbuf);
         else
            eina_strbuf_reset(tmpbuf);
         eina_strbuf_append(str_func, eina_strbuf_string_get(tmpbuf));
      }
 
    Eolian_Event event;
-   EINA_LIST_FOREACH(eolian_class_events_list_get(classname), itr, event)
+   EINA_LIST_FOREACH(eolian_class_events_list_get(class), itr, event)
      {
         const char *evname;
 
@@ -815,9 +811,10 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
 
    const char *inherit_name;
    eina_strbuf_reset(tmpbuf);
-   EINA_LIST_FOREACH(eolian_class_inherits_list_get(classname), itr, inherit_name)
+   EINA_LIST_FOREACH(eolian_class_inherits_list_get(class), itr, inherit_name)
      {
-        const char *eo_prefix = eolian_class_eo_prefix_get(inherit_name);
+        Eolian_Class inherit_class = eolian_class_find_by_name(inherit_name);
+        const char *eo_prefix = eolian_class_eo_prefix_get(inherit_class);
         if (!eo_prefix) eo_prefix = inherit_name;
         _template_fill(tmpbuf, "@#EOPREFIX_CLASS, ", eo_prefix, "", EINA_FALSE);
         eina_strbuf_replace_all(tmpbuf, "@#EOPREFIX", current_eo_prefix_upper);
@@ -849,7 +846,7 @@ eo_source_end_generate(const char *classname, Eina_Strbuf *buf)
    eina_strbuf_replace_all(str_end, "@#functions_body", eina_strbuf_string_get(str_bodyf));
    eina_strbuf_replace_all(str_end, "@#eo_class_desc_ops", eina_strbuf_string_get(tmpbuf));
 
-   const char *data_type = eolian_class_data_type_get(classname);
+   const char *data_type = eolian_class_data_type_get(class);
    if (data_type && !strcmp(data_type, "null"))
       eina_strbuf_replace_all(str_end, "@#SizeOfData", "0");
    else
@@ -877,7 +874,7 @@ end:
 }
 
 Eina_Bool
-eo_source_generate(const char *classname, Eina_Strbuf *buf)
+eo_source_generate(const Eolian_Class class, Eina_Strbuf *buf)
 {
    Eina_Bool ret = EINA_FALSE;
    const Eina_List *itr;
@@ -885,10 +882,10 @@ eo_source_generate(const char *classname, Eina_Strbuf *buf)
 
    Eina_Strbuf *str_bodyf = eina_strbuf_new();
 
-   if (!eo_source_beginning_generate(classname, buf)) goto end;
+   if (!eo_source_beginning_generate(class, buf)) goto end;
 
    //Properties
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, EOLIAN_PROPERTY), itr, fn)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_PROPERTY), itr, fn)
      {
         const Eolian_Function_Type ftype = eolian_function_type_get(fn);
 
@@ -897,24 +894,24 @@ eo_source_generate(const char *classname, Eina_Strbuf *buf)
 
         if (prop_write)
           {
-             if (!eo_bind_func_generate(classname, fn, EOLIAN_PROP_SET, str_bodyf, NULL)) goto end;
+             if (!eo_bind_func_generate(class, fn, EOLIAN_PROP_SET, str_bodyf, NULL)) goto end;
           }
         if (prop_read)
           {
-             if (!eo_bind_func_generate(classname, fn, EOLIAN_PROP_GET, str_bodyf, NULL)) goto end;
+             if (!eo_bind_func_generate(class, fn, EOLIAN_PROP_GET, str_bodyf, NULL)) goto end;
           }
      }
 
    //Methods
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, EOLIAN_METHOD), itr, fn)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_METHOD), itr, fn)
      {
-        if (!eo_bind_func_generate(classname, fn, EOLIAN_UNRESOLVED, str_bodyf, NULL)) goto end;
+        if (!eo_bind_func_generate(class, fn, EOLIAN_UNRESOLVED, str_bodyf, NULL)) goto end;
      }
 
    eina_strbuf_append(buf, eina_strbuf_string_get(str_bodyf));
    eina_strbuf_reset(str_bodyf);
 
-   if (!eo_source_end_generate(classname, buf)) goto end;
+   if (!eo_source_end_generate(class, buf)) goto end;
 
    ret = EINA_TRUE;
 end:
diff --git a/src/bin/eolian/eo1_generator.h b/src/bin/eolian/eo1_generator.h
index 7bab05439a..9d115e8e98 100644
--- a/src/bin/eolian/eo1_generator.h
+++ b/src/bin/eolian/eo1_generator.h
@@ -15,7 +15,7 @@
  *
  */
 Eina_Bool
-eo_source_generate(const char *classname, Eina_Strbuf *buf);
+eo_source_generate(const Eolian_Class class, Eina_Strbuf *buf);
 
 /*
  * @brief Generate the header code for a specific Eo class.
@@ -28,7 +28,7 @@ eo_source_generate(const char *classname, Eina_Strbuf *buf);
  * @return EINA_TRUE on success, EINA_FALSE on error.
  *
  */
-Eina_Bool eo_header_generate(const char *classname, Eina_Strbuf *buf);
+Eina_Bool eo_header_generate(const Eolian_Class class, Eina_Strbuf *buf);
 
 #endif
 
diff --git a/src/bin/eolian/impl_generator.c b/src/bin/eolian/impl_generator.c
index b2abf0ee35..867ac48335 100644
--- a/src/bin/eolian/impl_generator.c
+++ b/src/bin/eolian/impl_generator.c
@@ -143,13 +143,14 @@ _prototype_generate(Eolian_Function foo, Eolian_Function_Type ftype, Eina_Strbuf
 }
 
 Eina_Bool
-impl_source_generate(const char *class_name, Eina_Strbuf *buffer)
+impl_source_generate(const Eolian_Class class, Eina_Strbuf *buffer)
 {
    Eina_Bool ret = EINA_FALSE;
    Eina_Strbuf *data_type_buf = eina_strbuf_new();
    const Eina_List *itr_funcs;
    Eolian_Function foo;
    Eina_Strbuf *begin = eina_strbuf_new();
+   const char *class_name = eolian_class_name_get(class);
 
    _class_func_names_fill(class_name, NULL);
 
@@ -166,7 +167,7 @@ impl_source_generate(const char *class_name, Eina_Strbuf *buffer)
      }
 
    /* Little calculation of the prefix of the data */
-   const char *data_type = eolian_class_data_type_get(class_name);
+   const char *data_type = eolian_class_data_type_get(class);
    if (data_type)
      {
         if (strcmp(data_type, "null"))
@@ -188,7 +189,7 @@ impl_source_generate(const char *class_name, Eina_Strbuf *buffer)
    eina_strbuf_free(begin);
 
    /* Properties */
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(class_name, EOLIAN_PROPERTY), itr_funcs, foo)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_PROPERTY), itr_funcs, foo)
      {
         const Eolian_Function_Type ftype = eolian_function_type_get(foo);
         if (ftype == EOLIAN_PROP_SET || ftype == EOLIAN_PROPERTY)
@@ -199,39 +200,40 @@ impl_source_generate(const char *class_name, Eina_Strbuf *buffer)
      }
 
    /* Methods */
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(class_name, EOLIAN_METHOD), itr_funcs, foo)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_METHOD), itr_funcs, foo)
      {
         _prototype_generate(foo, EOLIAN_METHOD, data_type_buf, NULL, buffer);
      }
 
    /* Custom constructors */
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(class_name, EOLIAN_CTOR), itr_funcs, foo)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_CTOR), itr_funcs, foo)
      {
         _prototype_generate(foo, EOLIAN_CTOR, data_type_buf, NULL, buffer);
      }
 
-   if (eolian_class_implements_list_get(class_name))
+   if (eolian_class_implements_list_get(class))
      {
         Eolian_Implement impl_desc;
-        EINA_LIST_FOREACH(eolian_class_implements_list_get(class_name), itr_funcs, impl_desc)
+        EINA_LIST_FOREACH(eolian_class_implements_list_get(class), itr_funcs, impl_desc)
           {
              const char *func_name;
-             const char *impl_class;
+             const char *impl_classname;
              Eolian_Function_Type ftype;
 
-             eolian_implement_information_get(impl_desc, &impl_class, &func_name, &ftype);
+             eolian_implement_information_get(impl_desc, &impl_classname, &func_name, &ftype);
+             Eolian_Class impl_class = eolian_class_find_by_name(impl_classname);
 
-             _class_func_names_fill(impl_class, NULL);
+             _class_func_names_fill(impl_classname, NULL);
 
              char implname[0xFF];
              char *tmp = implname;
-             sprintf(implname, "%s_%s", class_name, impl_class);
+             sprintf(implname, "%s_%s", class_name, impl_classname);
              eina_str_tolower(&tmp);
 
              foo = eolian_class_function_find_by_name(impl_class, func_name, ftype);
              if (!foo)
                {
-                  ERR ("Failed to generate implementation of %s:%s - missing form super class", impl_class, func_name);
+                  ERR ("Failed to generate implementation of %s:%s - missing form super class", impl_classname, func_name);
                   goto end;
                }
 
@@ -248,7 +250,7 @@ impl_source_generate(const char *class_name, Eina_Strbuf *buffer)
      }
 
    _class_func_names_fill(class_name, NULL);
-   if (eolian_class_ctor_enable_get(class_name))
+   if (eolian_class_ctor_enable_get(class))
      {
         char func_name[100];
         sprintf(func_name, "_%s_class_constructor", lowclass);
@@ -261,7 +263,7 @@ impl_source_generate(const char *class_name, Eina_Strbuf *buffer)
           }
      }
 
-   if (eolian_class_dtor_enable_get(class_name))
+   if (eolian_class_dtor_enable_get(class))
      {
         char func_name[100];
         sprintf(func_name, "_%s_class_destructor", lowclass);
diff --git a/src/bin/eolian/impl_generator.h b/src/bin/eolian/impl_generator.h
index b6793d785b..7b98ac9ae9 100644
--- a/src/bin/eolian/impl_generator.h
+++ b/src/bin/eolian/impl_generator.h
@@ -15,7 +15,7 @@
  *
  */
 Eina_Bool
-impl_source_generate(const char *classname, Eina_Strbuf *buf);
+impl_source_generate(const Eolian_Class class, Eina_Strbuf *buf);
 
 #endif
 
diff --git a/src/bin/eolian/legacy_generator.c b/src/bin/eolian/legacy_generator.c
index 8c437921a3..46963b0829 100644
--- a/src/bin/eolian/legacy_generator.c
+++ b/src/bin/eolian/legacy_generator.c
@@ -41,7 +41,7 @@ EAPI void\n\
 ";
 
 static void
-_eapi_decl_func_generate(const char *classname, Eolian_Function funcid, Eolian_Function_Type ftype, Eina_Strbuf *buf)
+_eapi_decl_func_generate(Eolian_Class class, Eolian_Function funcid, Eolian_Function_Type ftype, Eina_Strbuf *buf)
 {
    //TODO return value
    const char *suffix = "";
@@ -95,10 +95,10 @@ _eapi_decl_func_generate(const char *classname, Eolian_Function funcid, Eolian_F
      }
    else
      {
-        func_lpref = eolian_class_legacy_prefix_get(classname);
+        func_lpref = eolian_class_legacy_prefix_get(class);
         if (func_lpref && !strcmp(func_lpref, "null")) goto end;
 
-        if (!func_lpref) func_lpref = classname;
+        if (!func_lpref) func_lpref = eolian_class_name_get(class);
         sprintf (tmpstr, "%s%s", eolian_function_name_get(funcid), suffix);
         _template_fill(fbody, tmpl_eapi_funcdef, func_lpref, tmpstr, EINA_FALSE);
      }
@@ -205,7 +205,7 @@ end:
 }
 
 static void
-_eapi_func_generate(const char *classname, Eolian_Function funcid, Eolian_Function_Type ftype, Eina_Strbuf *buf)
+_eapi_func_generate(const Eolian_Class class, Eolian_Function funcid, Eolian_Function_Type ftype, Eina_Strbuf *buf)
 {
    //TODO return value
    char tmpstr[0xFF];
@@ -217,6 +217,7 @@ _eapi_func_generate(const char *classname, Eolian_Function funcid, Eolian_Functi
    Eina_Bool ret_const = EINA_FALSE;
    Eina_Bool add_star = EINA_FALSE;
    Eina_Bool ret_is_void = EINA_FALSE;
+   const char *classname = eolian_class_name_get(class);
 
    Eina_Strbuf *fbody = eina_strbuf_new();
    Eina_Strbuf *fparam = eina_strbuf_new();
@@ -261,7 +262,7 @@ _eapi_func_generate(const char *classname, Eolian_Function funcid, Eolian_Functi
       eina_strbuf_replace_all(fbody, "@#eapi_prefix_@#func", func_lpref);
    else
      {
-        func_lpref = eolian_class_legacy_prefix_get(classname);
+        func_lpref = eolian_class_legacy_prefix_get(class);
         if (func_lpref && !strcmp(func_lpref, "null")) goto end;
 
         if (func_lpref) eina_strbuf_replace_all(fbody, "@#eapi_prefix", func_lpref);
@@ -344,19 +345,13 @@ end:
 }
 
 Eina_Bool
-legacy_header_generate(const char *classname, Eina_Strbuf *buf)
+legacy_header_generate(const Eolian_Class class, Eina_Strbuf *buf)
 {
    const Eolian_Function_Type ftype_order[] = {EOLIAN_PROPERTY, EOLIAN_METHOD};
    const Eina_List *l;
    void *data;
 
-   if (!eolian_class_exists(classname))
-     {
-        printf ("Class \"%s\" not found in database\n", classname);
-        return EINA_FALSE;
-     }
-
-   const char *desc = eolian_class_description_get(classname);
+   const char *desc = eolian_class_description_get(class);
    Eina_Strbuf *linedesc = eina_strbuf_new();
    eina_strbuf_append(linedesc, "/**\n");
    if (desc)
@@ -372,7 +367,7 @@ legacy_header_generate(const char *classname, Eina_Strbuf *buf)
 
    int i;
    for (i = 0; i < 2; i++)
-      EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, ftype_order[i]), l, data)
+      EINA_LIST_FOREACH(eolian_class_functions_list_get(class, ftype_order[i]), l, data)
         {
            const Eolian_Function_Type ftype = eolian_function_type_get((Eolian_Function)data);
            Eina_Bool prop_read = (ftype == EOLIAN_PROPERTY || ftype == EOLIAN_PROP_GET ) ? EINA_TRUE : EINA_FALSE ;
@@ -380,38 +375,32 @@ legacy_header_generate(const char *classname, Eina_Strbuf *buf)
 
            if (!prop_read && !prop_write)
              {
-                _eapi_decl_func_generate(classname, (Eolian_Function)data, EOLIAN_METHOD, buf);
+                _eapi_decl_func_generate(class, (Eolian_Function)data, EOLIAN_METHOD, buf);
              }
            if (prop_write)
              {
-                _eapi_decl_func_generate(classname, (Eolian_Function)data, EOLIAN_PROP_SET, buf);
+                _eapi_decl_func_generate(class, (Eolian_Function)data, EOLIAN_PROP_SET, buf);
              }
            if (prop_read)
              {
-                _eapi_decl_func_generate(classname, (Eolian_Function)data, EOLIAN_PROP_GET, buf);
+                _eapi_decl_func_generate(class, (Eolian_Function)data, EOLIAN_PROP_GET, buf);
              }
         }
    return EINA_TRUE;
 }
 
 Eina_Bool
-legacy_source_generate(const char *classname, Eina_Strbuf *buf)
+legacy_source_generate(const Eolian_Class class, Eina_Strbuf *buf)
 {
    Eina_Bool ret = EINA_FALSE;
    const Eina_List *itr;
    Eolian_Function fn;
 
-   if (!eolian_class_exists(classname))
-     {
-        printf ("Class \"%s\" not found in database\n", classname);
-        return EINA_FALSE;
-     }
-
    Eina_Strbuf *tmpbuf = eina_strbuf_new();
    Eina_Strbuf *str_bodyf = eina_strbuf_new();
 
    //Properties
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, EOLIAN_PROPERTY), itr, fn)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_PROPERTY), itr, fn)
      {
         const Eolian_Function_Type ftype = eolian_function_type_get(fn);
 
@@ -420,18 +409,18 @@ legacy_source_generate(const char *classname, Eina_Strbuf *buf)
 
         if (prop_write)
           {
-             _eapi_func_generate(classname, fn, EOLIAN_PROP_SET, str_bodyf);
+             _eapi_func_generate(class, fn, EOLIAN_PROP_SET, str_bodyf);
           }
         if (prop_read)
           {
-             _eapi_func_generate(classname, fn, EOLIAN_PROP_GET, str_bodyf);
+             _eapi_func_generate(class, fn, EOLIAN_PROP_GET, str_bodyf);
           }
      }
 
    //Methods
-   EINA_LIST_FOREACH(eolian_class_functions_list_get(classname, EOLIAN_METHOD), itr, fn)
+   EINA_LIST_FOREACH(eolian_class_functions_list_get(class, EOLIAN_METHOD), itr, fn)
      {
-        _eapi_func_generate(classname, fn, EOLIAN_UNRESOLVED, str_bodyf);
+        _eapi_func_generate(class, fn, EOLIAN_UNRESOLVED, str_bodyf);
      }
 
    eina_strbuf_append(buf, eina_strbuf_string_get(str_bodyf));
diff --git a/src/bin/eolian/legacy_generator.h b/src/bin/eolian/legacy_generator.h
index cf7faa9d9c..ddc616e43a 100644
--- a/src/bin/eolian/legacy_generator.h
+++ b/src/bin/eolian/legacy_generator.h
@@ -16,7 +16,7 @@
  * @return EINA_TRUE on success, EINA_FALSE on error.
  *
  */
-Eina_Bool legacy_header_generate(const char *classname, Eina_Strbuf *buf);
+Eina_Bool legacy_header_generate(const Eolian_Class class, Eina_Strbuf *buf);
 
 /*
  * @brief Generate C source code for Eo class
@@ -30,7 +30,7 @@ Eina_Bool legacy_header_generate(const char *classname, Eina_Strbuf *buf);
  * @return EINA_TRUE on success, EINA_FALSE on error.
  *
  */
-Eina_Bool legacy_source_generate(const char *classname, Eina_Strbuf *buf);
+Eina_Bool legacy_source_generate(const Eolian_Class class, Eina_Strbuf *buf);
 
 #endif
 
diff --git a/src/bin/eolian/main.c b/src/bin/eolian/main.c
index 8ceb3cf16f..84fa08366c 100644
--- a/src/bin/eolian/main.c
+++ b/src/bin/eolian/main.c
@@ -41,13 +41,13 @@ _filename_get(const char *path)
 }
 
 static Eina_Bool
-_generate_eo_h_file(char *filename, const char *classname)
+_generate_eo_h_file(char *filename, const Eolian_Class class)
 {
    Eina_Bool ret = EINA_FALSE;
    Eina_Strbuf *hfile = eina_strbuf_new();
-   if (!eo_header_generate(classname, hfile))
+   if (!eo_header_generate(class, hfile))
      {
-        ERR("Failed to generate header for %s", classname);
+        ERR("Failed to generate header for %s", eolian_class_name_get(class));
         goto end;
      }
 
@@ -78,23 +78,23 @@ end:
 }
 
 static Eina_Bool
-_generate_c_file(char *filename, const char *classname, Eina_Bool legacy_support)
+_generate_c_file(char *filename, const Eolian_Class class, Eina_Bool legacy_support)
 {
    Eina_Bool ret = EINA_FALSE;
 
    Eina_Strbuf *eo_buf = eina_strbuf_new();
    Eina_Strbuf *legacy_buf = eina_strbuf_new();
 
-   if (!eo_source_generate(classname, eo_buf))
+   if (!eo_source_generate(class, eo_buf))
      {
-        ERR("Failed to generate source for %s", classname);
+        ERR("Failed to generate source for %s", eolian_class_name_get(class));
         goto end;
      }
 
    if (legacy_support)
-      if (!legacy_source_generate(classname, legacy_buf))
+      if (!legacy_source_generate(class, legacy_buf))
         {
-           ERR("Failed to generate source for %s", classname);
+           ERR("Failed to generate source for %s", eolian_class_name_get(class));
            goto end;
         }
 
@@ -120,7 +120,7 @@ end:
 }
 
 static Eina_Bool
-_generate_impl_c_file(char *filename, const char *classname)
+_generate_impl_c_file(char *filename, const Eolian_Class class)
 {
    Eina_Bool ret = EINA_FALSE;
    long file_size = 0;
@@ -148,9 +148,9 @@ _generate_impl_c_file(char *filename, const char *classname)
    else
       buffer = eina_strbuf_new();
 
-   if (!impl_source_generate(classname, buffer))
+   if (!impl_source_generate(class, buffer))
      {
-        ERR("Failed to generate source for %s", classname);
+        ERR("Failed to generate source for %s", eolian_class_name_get(class));
         goto end;
      }
 
@@ -174,15 +174,15 @@ end:
 
 // TODO join with header gen.
 static Eina_Bool
-_generate_legacy_header_file(char *filename, const char *classname)
+_generate_legacy_header_file(char *filename, const Eolian_Class class)
 {
    Eina_Bool ret = EINA_FALSE;
 
    Eina_Strbuf *lfile = eina_strbuf_new();
 
-   if (!legacy_header_generate(classname, lfile))
+   if (!legacy_header_generate(class, lfile))
      {
-        ERR("Failed to generate header for %s", classname);
+        ERR("Failed to generate header for %s", eolian_class_name_get(class));
         goto end;
      }
 
@@ -227,7 +227,7 @@ int main(int argc, char **argv)
    Eina_Bool help = EINA_FALSE, show = EINA_FALSE;
    Eina_List *itr;
    Eina_List *files4gen = NULL;
-   const char *classname;
+   Eolian_Class class;
    char *output_filename = NULL; /* if NULL, have to generate, otherwise use the name stored there */
 
    eina_init();
@@ -322,8 +322,8 @@ int main(int argc, char **argv)
      {
         EINA_LIST_FOREACH(files4gen, itr, filename)
           {
-             const char *cname = eolian_class_find_by_file(filename);
-             if (cname) eolian_show(cname);
+             class = eolian_class_find_by_file(filename);
+             if (class) eolian_show(class);
           }
      }
 
@@ -333,7 +333,7 @@ int main(int argc, char **argv)
         goto end;
      }
 
-   classname = eolian_class_find_by_file(eina_list_data_get(files4gen));
+   class = eolian_class_find_by_file(eina_list_data_get(files4gen));
 
    if (gen_opt)
      {
@@ -348,21 +348,21 @@ int main(int argc, char **argv)
                 {
                    INF("Generating header file %s\n", output_filename);
                    if (legacy_support)
-                     ret = ( _generate_legacy_header_file(output_filename, classname) ? 0 : 1 );
+                     ret = ( _generate_legacy_header_file(output_filename, class) ? 0 : 1 );
                    else
-                     ret = ( _generate_eo_h_file(output_filename, classname) ? 0 : 1 );
+                     ret = ( _generate_eo_h_file(output_filename, class) ? 0 : 1 );
                    break;
                 }
            case C_GEN:
                 {
                    INF("Generating source file %s\n", output_filename);
-                   ret = _generate_c_file(output_filename, classname, legacy_support)?0:1;
+                   ret = _generate_c_file(output_filename, class, legacy_support)?0:1;
                    break;
                 }
            case C_IMPL_GEN:
                 {
                    INF("Generating user source file %s\n", output_filename);
-                   ret = _generate_impl_c_file(output_filename, classname) ? 0 : 1;
+                   ret = _generate_impl_c_file(output_filename, class) ? 0 : 1;
                    break;
                 }
            default:
diff --git a/src/bin/eolian_cxx/comments.cc b/src/bin/eolian_cxx/comments.cc
index afe725f300..d82f2b424c 100644
--- a/src/bin/eolian_cxx/comments.cc
+++ b/src/bin/eolian_cxx/comments.cc
@@ -73,9 +73,9 @@ _comment_return(Eolian_Function function,
 namespace detail {
 
 std::string
-eolian_class_comment(const char *classname)
+eolian_class_comment(const Eolian_Class kls)
 {
-   return safe_str(eolian_class_description_get(classname));
+   return safe_str(eolian_class_description_get(kls));
 }
 
 std::string
diff --git a/src/bin/eolian_cxx/comments.hh b/src/bin/eolian_cxx/comments.hh
index 3aaf7562ce..c8378bc689 100644
--- a/src/bin/eolian_cxx/comments.hh
+++ b/src/bin/eolian_cxx/comments.hh
@@ -14,7 +14,7 @@ extern "C"
 
 namespace detail {
 
-std::string eolian_class_comment(const char *classname);
+std::string eolian_class_comment(const Eolian_Class kls);
 
 std::string eolian_constructor_comment(Eolian_Function constructor);
 
diff --git a/src/bin/eolian_cxx/convert.cc b/src/bin/eolian_cxx/convert.cc
index 8827899014..4a4215c763 100644
--- a/src/bin/eolian_cxx/convert.cc
+++ b/src/bin/eolian_cxx/convert.cc
@@ -55,20 +55,20 @@ _get_params(const Eina_List *eolian_params, bool is_get = false)
 }
 
 static efl::eolian::functions_container_type
-_get_properties(const char *classname)
+_get_properties(const Eolian_Class klass)
 {
    efl::eolian::functions_container_type container;
 
-   std::string cxx_classname = classname;
+   std::string cxx_classname = eolian_class_name_get(klass);
    std::transform(cxx_classname.begin(), cxx_classname.end(),
                   cxx_classname.begin(), ::tolower);
 
    const Eina_List *properties;
-   properties = eolian_class_functions_list_get(classname, EOLIAN_PROPERTY);
+   properties = eolian_class_functions_list_get(klass, EOLIAN_PROPERTY);
 
    const Eina_List *it;
    void *curr;
-   std::string prefix(safe_str(eolian_class_eo_prefix_get(classname)));
+   std::string prefix(safe_str(eolian_class_eo_prefix_get(klass)));
    EINA_LIST_FOREACH (properties, it, curr)
      {
         Eolian_Function property = static_cast<Eolian_Function>(curr);
@@ -142,9 +142,9 @@ _get_properties(const char *classname)
 namespace detail {
 
 void
-convert_eolian_inheritances(efl::eolian::eo_class& cls, const char *classname)
+convert_eolian_inheritances(efl::eolian::eo_class& cls, const Eolian_Class klass)
 {
-   const Eina_List *inheritances = eolian_class_inherits_list_get(classname);
+   const Eina_List *inheritances = eolian_class_inherits_list_get(klass);
    const Eina_List *it;
    void *curr;
 
@@ -174,25 +174,26 @@ convert_eolian_inheritances(efl::eolian::eo_class& cls, const char *classname)
 }
 
 void
-convert_eolian_implements(efl::eolian::eo_class& cls, const char *classname)
+convert_eolian_implements(efl::eolian::eo_class& cls, const Eolian_Class klass)
 {
    const Eina_List *it;
-   std::string prefix(safe_str(eolian_class_eo_prefix_get(classname)));
+   std::string prefix(safe_str(eolian_class_eo_prefix_get(klass)));
    void *impl_desc_;
-   EINA_LIST_FOREACH(eolian_class_implements_list_get(classname), it, impl_desc_)
+   EINA_LIST_FOREACH(eolian_class_implements_list_get(klass), it, impl_desc_)
      {
         Eolian_Implement impl_desc = static_cast<Eolian_Implement>(impl_desc_);
-        const char *impl_class;
+        const char *impl_classname;
         const char *func_name;
         Eolian_Function_Type func_type;
         eolian_implement_information_get
-          (impl_desc, &impl_class, &func_name, &func_type);
+          (impl_desc, &impl_classname, &func_name, &func_type);
         if (func_type == EOLIAN_CTOR)
           {
              efl::eolian::eo_constructor constructor;
+             Eolian_Class impl_class = eolian_class_find_by_name(impl_classname);
              Eolian_Function eolian_constructor =
                 eolian_class_function_find_by_name(impl_class, func_name, func_type);
-             std::string parent = safe_str(impl_class);
+             std::string parent = safe_str(impl_classname);
              if(parent == "Eo_Base") parent = "eo";
              else std::transform(parent.begin(), parent.end(), parent.begin(), ::tolower);
              constructor.name = parent + "_" + safe_str(func_name);
@@ -206,13 +207,13 @@ convert_eolian_implements(efl::eolian::eo_class& cls, const char *classname)
 }
 
 void
-convert_eolian_constructors(efl::eolian::eo_class& cls, const char *classname)
+convert_eolian_constructors(efl::eolian::eo_class& cls, const Eolian_Class klass)
 {
    const Eina_List *it;
    void *curr;
-   std::string prefix(safe_str(eolian_class_eo_prefix_get(classname)));
+   std::string prefix(safe_str(eolian_class_eo_prefix_get(klass)));
    const Eina_List *constructors =
-     eolian_class_functions_list_get(classname, EOLIAN_CTOR);
+     eolian_class_functions_list_get(klass, EOLIAN_CTOR);
    EINA_LIST_FOREACH (constructors, it, curr)
      {
         Eolian_Function eolian_constructor = static_cast<Eolian_Function>(curr);
@@ -228,18 +229,18 @@ convert_eolian_constructors(efl::eolian::eo_class& cls, const char *classname)
 }
 
 void
-convert_eolian_functions(efl::eolian::eo_class& cls, const char *classname)
+convert_eolian_functions(efl::eolian::eo_class& cls, const Eolian_Class klass)
 {
    const Eina_List *it;
    void *curr;
 
    const Eina_List *eolian_functions =
-     eolian_class_functions_list_get(classname, EOLIAN_METHOD);
+     eolian_class_functions_list_get(klass, EOLIAN_METHOD);
    EINA_LIST_FOREACH (eolian_functions, it, curr)
      {
         efl::eolian::eo_function function;
         Eolian_Function eolian_function = static_cast<Eolian_Function>(curr);
-        std::string prefix(safe_str(eolian_class_eo_prefix_get(classname)));
+        std::string prefix(safe_str(eolian_class_eo_prefix_get(klass)));
         // XXX Eolian only provides regular methods so far
         function.type = efl::eolian::eo_function::regular_;
         function.name = safe_str(eolian_function_name_get(eolian_function));
@@ -254,29 +255,29 @@ convert_eolian_functions(efl::eolian::eo_class& cls, const char *classname)
 }
 
 void
-convert_eolian_properties(efl::eolian::eo_class& cls, const char *classname)
+convert_eolian_properties(efl::eolian::eo_class& cls, const Eolian_Class klass)
 {
-   efl::eolian::functions_container_type properties = _get_properties(classname);
+   efl::eolian::functions_container_type properties = _get_properties(klass);
    cls.functions.insert(cls.functions.end(), properties.begin(), properties.end());
 }
 
 } // namespace detail {
 
 efl::eolian::eo_class
-_cxx_new(const char *classname)
+_cxx_new(const Eolian_Class klass)
 {
    using namespace efl::eolian;
    eo_class cls;
-   Eolian_Class_Type cls_type = ::eolian_class_type_get(classname);
+   Eolian_Class_Type cls_type = ::eolian_class_type_get(klass);
    if      (cls_type == EOLIAN_CLASS_REGULAR)   cls.type = eo_class::regular_;
    else if (cls_type == EOLIAN_CLASS_ABSTRACT)  cls.type = eo_class::regular_noninst_;
    else if (cls_type == EOLIAN_CLASS_MIXIN)     cls.type = eo_class::mixin_;
    else if (cls_type == EOLIAN_CLASS_INTERFACE) cls.type = eo_class::interface_;
    else    { assert(false); }
-   std::string prefix(safe_str(eolian_class_eo_prefix_get(classname)));
-   cls.name = classname;
+   std::string prefix(safe_str(eolian_class_eo_prefix_get(klass)));
+   cls.name = eolian_class_name_get(klass);
    cls.eo_name = (prefix != "" ? prefix : cls.name) + "_CLASS";
-   cls.comment = detail::eolian_class_comment(classname);
+   cls.comment = detail::eolian_class_comment(klass);
    std::transform(cls.name.begin(), cls.name.end(), cls.name.begin(), ::tolower);
    std::transform(cls.eo_name.begin(), cls.eo_name.end(), cls.eo_name.begin(), ::toupper);
    return cls;
@@ -285,11 +286,12 @@ _cxx_new(const char *classname)
 efl::eolian::eo_class
 c_to_cxx(const char *classname)
 {
-   efl::eolian::eo_class cls(_cxx_new(classname));
-   detail::convert_eolian_inheritances(cls, classname);
-   detail::convert_eolian_implements(cls, classname);
-   detail::convert_eolian_constructors(cls, classname);
-   detail::convert_eolian_functions(cls, classname);
-   detail::convert_eolian_properties(cls, classname);
+   Eolian_Class klass = eolian_class_find_by_name(classname);
+   efl::eolian::eo_class cls(_cxx_new(klass));
+   detail::convert_eolian_inheritances(cls, klass);
+   detail::convert_eolian_implements(cls, klass);
+   detail::convert_eolian_constructors(cls, klass);
+   detail::convert_eolian_functions(cls, klass);
+   detail::convert_eolian_properties(cls, klass);
    return cls;
 }
diff --git a/src/bin/eolian_cxx/eolian_cxx.cc b/src/bin/eolian_cxx/eolian_cxx.cc
index d3e194d15c..e58ea6399d 100644
--- a/src/bin/eolian_cxx/eolian_cxx.cc
+++ b/src/bin/eolian_cxx/eolian_cxx.cc
@@ -84,9 +84,9 @@ _guess_classname_from_sources(::options_type& opts)
 {
    for (auto filename : opts.in_srcs)
      {
-        if (const char *cls = eolian_class_find_by_file(filename.c_str()))
+        if (Eolian_Class klass = eolian_class_find_by_file(filename.c_str()))
           {
-             return cls;
+             return eolian_class_name_get(klass);
           }
      }
    return "";
@@ -119,16 +119,17 @@ _resolve_includes(std::string const& classname)
    efl::eolian::eo_generator_options gen_opts;
 
    std::string cls_name = classname;
+   Eolian_Class klass = eolian_class_find_by_name(classname.c_str());
    std::transform(cls_name.begin(), cls_name.end(), cls_name.begin(), ::tolower);
 
-   std::string eo_file = safe_str(eolian_class_file_get(classname.c_str()));
+   std::string eo_file = safe_str(eolian_class_file_get(klass));
    gen_opts.c_headers.push_back(get_filename_info(eo_file).first + ".h");
 
    void *cur = NULL;
-   const Eina_List *itr, *inheritances = eolian_class_inherits_list_get(classname.c_str());
+   const Eina_List *itr, *inheritances = eolian_class_inherits_list_get(klass);
    EINA_LIST_FOREACH(inheritances, itr, cur)
      {
-        const char *ext = static_cast<const char*>(cur);
+        Eolian_Class ext = eolian_class_find_by_name(static_cast<const char*>(cur));
         std::string eo_parent_file = safe_str(eolian_class_file_get(ext));
         if (!eo_parent_file.empty())
           {
diff --git a/src/lib/eolian/Eolian.h b/src/lib/eolian/Eolian.h
index 8bb777020f..ed7c44c43f 100644
--- a/src/lib/eolian/Eolian.h
+++ b/src/lib/eolian/Eolian.h
@@ -38,6 +38,12 @@ extern "C" {
 
 #ifdef EFL_BETA_API_SUPPORT
 
+/* Class type used to extract information on classes
+ *
+ * @ingroup Eolian
+ */
+typedef struct _Class_Desc* Eolian_Class;
+
 /* Function Id used to extract information on class functions
  *
  * @ingroup Eolian
@@ -172,44 +178,64 @@ EAPI Eina_Bool eolian_all_eo_files_parse();
 /*
  * @brief Show information about a given class.
  *
- * If class_name is NULL, this function will print information of
+ * If klass is NULL, this function will print information of
  * all the classes stored into the database.
  *
- * @param[in] class_name the class to show
+ * @param[in] klass the class to show
  *
  * @ingroup Eolian
  */
-EAPI Eina_Bool eolian_show(const char *class_name);
+EAPI Eina_Bool eolian_show(const Eolian_Class klass);
+
+/*
+ * @brief Finds a class by its name
+ *
+ * @param[in] class_name name of the class to find.
+ * @return the class
+ *
+ * @ingroup Eolian
+ */
+EAPI Eolian_Class
+eolian_class_find_by_name(const char *class_name);
 
 /*
  * @brief Finds a class by its location (.eo file)
  *
  * @param[in] file_name filename where the class is stored.
- * @return the class name stored in the file
+ * @return the class stored in the file
  *
  * @ingroup Eolian
  */
-EAPI const char *
+EAPI Eolian_Class
 eolian_class_find_by_file(const char *file_name);
 
 /*
  * @brief Returns the name of the file containing the given class.
  *
- * @param[in] class_name name of the class.
+ * @param[in] klass the class.
  * @return the name of the file on success or NULL otherwise.
  */
 EAPI const char *
-eolian_class_file_get(const char *class_name);
+eolian_class_file_get(const Eolian_Class klass);
+
+/*
+ * @brief Returns the name of the given class.
+ *
+ * @param[in] class the class.
+ * @return the name of the class on success or NULL otherwise.
+ */
+EAPI const char *
+eolian_class_name_get(const Eolian_Class klass);
 
 /*
  * @brief Returns the class type of the given class
  *
- * @param[in] class_name name of the class
+ * @param[in] klass the class
  * @return the class type
  *
  * @ingroup Eolian
  */
-EAPI Eolian_Class_Type eolian_class_type_get(const char *class_name);
+EAPI Eolian_Class_Type eolian_class_type_get(const Eolian_Class klass);
 
 /*
  * @brief Returns the names list of all the classes stored into the database.
@@ -222,76 +248,66 @@ EAPI Eolian_Class_Type eolian_class_type_get(const char *class_name);
 EAPI const Eina_List *eolian_class_names_list_get(void);
 
 /*
- * @brief Indicates if class exists in the database.
- *
- * @param[in] class_name name of the class
- * @return EINA_TRUE if exists, EINA_FALSE otherwise
- *
- * @ingroup Eolian
- */
-EAPI Eina_Bool eolian_class_exists(const char *class_name);
-
-/*
  * @brief Returns the description of a class.
  *
- * @param[in] class_name name of the class
+ * @param[in] klass the class
  * @return the description of a class
  *
  * @ingroup Eolian
  */
-EAPI const char *eolian_class_description_get(const char *class_name);
+EAPI const char *eolian_class_description_get(const Eolian_Class klass);
 
 /*
  * @brief Returns the legacy prefix of a class
  *
- * @param[in] class_name name of the class
+ * @param[in] klass the class
  * @return the legacy prefix
  *
  * @ingroup Eolian
  */
-EAPI const char *eolian_class_legacy_prefix_get(const char *class_name);
+EAPI const char *eolian_class_legacy_prefix_get(const Eolian_Class klass);
 
 /*
  * @brief Returns the eo prefix of a class
  *
- * @param[in] class_name name of the class
+ * @param[in] klass the class
  * @return the eo prefix
  *
  * @ingroup Eolian
  */
-EAPI const char* eolian_class_eo_prefix_get(const char *class_name);
+EAPI const char* eolian_class_eo_prefix_get(const Eolian_Class klass);
 
 /*
  * @brief Returns the data type of a class
  *
- * @param[in] class_name name of the class
+ * @param[in] klass the class
  * @return the data type
  *
  * @ingroup Eolian
  */
 EAPI const char*
-eolian_class_data_type_get(const char *class_name);
+eolian_class_data_type_get(const Eolian_Class klass);
 
 /*
  * @brief Returns the names list of the inherit classes of a class
  *
- * @param[in] class_name name of the class
+ * @param[in] klass the class
  * @return the list
  *
  * @ingroup Eolian
  */
-EAPI const Eina_List *eolian_class_inherits_list_get(const char *class_name);
+EAPI const Eina_List *eolian_class_inherits_list_get(const Eolian_Class klass);
 
 /*
  * @brief Returns a list of functions of a class.
  *
- * @param[in] class_name name of the class
+ * @param[in] klass the class
  * @param[in] func_type type of the functions to insert into the list.
  * @return the list of Eolian_Function
  *
  * @ingroup Eolian
  */
-EAPI const Eina_List *eolian_class_functions_list_get(const char *class_name, Eolian_Function_Type func_type);
+EAPI const Eina_List *eolian_class_functions_list_get(const Eolian_Class klass, Eolian_Function_Type func_type);
 
 /*
  * @brief Returns the type of a function
@@ -326,14 +342,14 @@ EAPI const char *eolian_function_name_get(Eolian_Function function_id);
 /*
  * @brief Find a function in a class by its name and type
  *
- * @param[in] class_name name of the class
+ * @param[in] klass the class
  * @param[in] func_name name of the function
  * @param[in] f_type type of the function
  * @return the function id if found, NULL otherwise.
  *
  * @ingroup Eolian
  */
-EAPI Eolian_Function eolian_class_function_find_by_name(const char *classname, const char *func_name, Eolian_Function_Type f_type);
+EAPI Eolian_Function eolian_class_function_find_by_name(const Eolian_Class klass, const char *func_name, Eolian_Function_Type f_type);
 
 /*
  * @brief Returns a specific data for a function.
@@ -587,22 +603,22 @@ EAPI Eina_Bool eolian_implement_information_get(Eolian_Implement impl,
 /*
  * @brief Get the list of overriding functions defined in a class.
  *
- * @param[in] class_name name of the class.
+ * @param[in] klass the class.
  * @return a list of Eolian_Implement handles
  *
  * @ingroup Eolian
  */
-EAPI const Eina_List *eolian_class_implements_list_get(const char *class_name);
+EAPI const Eina_List *eolian_class_implements_list_get(const Eolian_Class klass);
 
 /*
  * @brief Get the list of events defined in a class.
  *
- * @param[in] class_name name of the class.
+ * @param[in] klass the class.
  * @return a list of Eolian_Event handles
  *
  * @ingroup Eolian
  */
-EAPI const Eina_List *eolian_class_events_list_get(const char *class_name);
+EAPI const Eina_List *eolian_class_events_list_get(const Eolian_Class klass);
 
 /*
  * @brief Get information about an event.
@@ -620,23 +636,23 @@ EAPI Eina_Bool eolian_class_event_information_get(Eolian_Event event, const char
  * @brief Indicates if the class constructor has to invoke
  * a non-generated class constructor function.
  *
- * @param[in] class_name name of the class.
+ * @param[in] klass the class.
  * @return EINA_TRUE if the invocation is needed, EINA_FALSE otherwise.
  *
  * @ingroup Eolian
  */
-EAPI Eina_Bool eolian_class_ctor_enable_get(const char *class_name);
+EAPI Eina_Bool eolian_class_ctor_enable_get(const Eolian_Class klass);
 
 /*
  * @brief Indicates if the class destructor has to invoke
  * a non-generated class destructor function.
  *
- * @param[in] class_name name of the class.
+ * @param[in] klass the class.
  * @return EINA_TRUE if the invocation is needed, EINA_FALSE otherwise.
  *
  * @ingroup Eolian
  */
-EAPI Eina_Bool eolian_class_dtor_enable_get(const char *class_name);
+EAPI Eina_Bool eolian_class_dtor_enable_get(const Eolian_Class klass);
 
 /*
  * @brief Find the type for a certain alias
diff --git a/src/lib/eolian/eo_lexer.c b/src/lib/eolian/eo_lexer.c
index 36141dbbf7..4d547f784b 100644
--- a/src/lib/eolian/eo_lexer.c
+++ b/src/lib/eolian/eo_lexer.c
@@ -4504,30 +4504,30 @@ eo_tokenizer_database_fill(const char *filename)
 
    EINA_LIST_FOREACH(toknz->classes, k, kls)
      {
-        database_class_add(kls->name, kls->type);
-        database_class_file_set(kls->name, filename);
+        Eolian_Class class = database_class_add(kls->name, kls->type);
+        database_class_file_set(class, filename);
 
-        if (kls->comment) database_class_description_set(kls->name, kls->comment);
+        if (kls->comment) database_class_description_set(class, kls->comment);
 
         EINA_LIST_FOREACH(kls->inherits, l, s)
-           database_class_inherit_add(kls->name, s);
+           database_class_inherit_add(class, s);
 
         if (kls->legacy_prefix)
           {
-             database_class_legacy_prefix_set(kls->name, kls->legacy_prefix);
+             database_class_legacy_prefix_set(class, kls->legacy_prefix);
           }
         if (kls->eo_prefix)
           {
-             database_class_eo_prefix_set(kls->name, kls->eo_prefix);
+             database_class_eo_prefix_set(class, kls->eo_prefix);
           }
         if (kls->data_type)
           {
-             database_class_data_type_set(kls->name, kls->data_type);
+             database_class_data_type_set(class, kls->data_type);
           }
         EINA_LIST_FOREACH(kls->constructors, l, meth)
           {
              Eolian_Function foo_id = database_function_new(meth->name, EOLIAN_CTOR);
-             database_class_function_add(kls->name, foo_id);
+             database_class_function_add(class, foo_id);
              if (meth->ret) database_function_return_comment_set(foo_id, EOLIAN_METHOD, meth->ret->comment);
              database_function_data_set(foo_id, EOLIAN_LEGACY, meth->legacy);
              EINA_LIST_FOREACH(meth->params, m, param)
@@ -4596,14 +4596,14 @@ eo_tokenizer_database_fill(const char *filename)
                             }
                     }
                }
-             database_class_function_add(kls->name, foo_id);
+             database_class_function_add(class, foo_id);
           }
 
         EINA_LIST_FOREACH(kls->methods, l, meth)
           {
              Eolian_Function foo_id = database_function_new(meth->name, EOLIAN_METHOD);
              database_function_scope_set(foo_id, meth->scope);
-             database_class_function_add(kls->name, foo_id);
+             database_class_function_add(class, foo_id);
              if (meth->ret)
                {
                   Eolian_Type types = _types_extract(meth->ret->type, strlen(meth->ret->type));
@@ -4628,20 +4628,20 @@ eo_tokenizer_database_fill(const char *filename)
 
         EINA_LIST_FOREACH(kls->implements, l, impl)
           {
-             const char *class = impl->meth_name;
+             const char *impl_class = impl->meth_name;
              Eina_Bool virtual_pure = EINA_FALSE;
-             if (!strcmp(class, "class::constructor"))
+             if (!strcmp(impl_class, "class::constructor"))
                {
-                  database_class_ctor_enable_set(kls->name, EINA_TRUE);
+                  database_class_ctor_enable_set(class, EINA_TRUE);
                   continue;
                }
-             if (!strcmp(class, "class::destructor"))
+             if (!strcmp(impl_class, "class::destructor"))
                {
-                  database_class_dtor_enable_set(kls->name, EINA_TRUE);
+                  database_class_dtor_enable_set(class, EINA_TRUE);
                   continue;
                }
-             if (!strncmp(class, "virtual::", 9)) virtual_pure = EINA_TRUE;
-             char *func = strstr(class, "::");
+             if (!strncmp(impl_class, "virtual::", 9)) virtual_pure = EINA_TRUE;
+             char *func = strstr(impl_class, "::");
              if (func) *func = '\0';
              func += 2;
              Eolian_Function_Type ftype = EOLIAN_UNRESOLVED;
@@ -4656,23 +4656,23 @@ eo_tokenizer_database_fill(const char *filename)
                {
                   /* Search the function into the existing functions of the current class */
                   Eolian_Function foo_id = eolian_class_function_find_by_name(
-                        kls->name, func, ftype);
+                        class, func, ftype);
                   if (!foo_id)
                     {
-                       ERR("Error - %s not known in class %s", class + 9, kls->name);
+                       ERR("Error - %s not known in class %s", impl_class + 9, eolian_class_name_get(class));
                        goto end;
                     }
                   database_function_set_as_virtual_pure(foo_id, ftype);
                   continue;
                }
-             Eolian_Implement impl_desc = database_implement_new(class, func, ftype);
-             database_class_implement_add(kls->name, impl_desc);
+             Eolian_Implement impl_desc = database_implement_new(impl_class, func, ftype);
+             database_class_implement_add(class, impl_desc);
           }
 
         EINA_LIST_FOREACH(kls->events, l, event)
           {
              Eolian_Event ev = database_event_new(event->name, event->type, event->comment);
-             database_class_event_add(kls->name, ev);
+             database_class_event_add(class, ev);
           }
 
      }
diff --git a/src/lib/eolian/eo_lexer.rl b/src/lib/eolian/eo_lexer.rl
index 81a124aed1..b13c809cd6 100644
--- a/src/lib/eolian/eo_lexer.rl
+++ b/src/lib/eolian/eo_lexer.rl
@@ -1388,30 +1388,30 @@ eo_tokenizer_database_fill(const char *filename)
 
    EINA_LIST_FOREACH(toknz->classes, k, kls)
      {
-        database_class_add(kls->name, kls->type);
-        database_class_file_set(kls->name, filename);
+        Eolian_Class class = database_class_add(kls->name, kls->type);
+        database_class_file_set(class, filename);
 
-        if (kls->comment) database_class_description_set(kls->name, kls->comment);
+        if (kls->comment) database_class_description_set(class, kls->comment);
 
         EINA_LIST_FOREACH(kls->inherits, l, s)
-           database_class_inherit_add(kls->name, s);
+           database_class_inherit_add(class, s);
 
         if (kls->legacy_prefix)
           {
-             database_class_legacy_prefix_set(kls->name, kls->legacy_prefix);
+             database_class_legacy_prefix_set(class, kls->legacy_prefix);
           }
         if (kls->eo_prefix)
           {
-             database_class_eo_prefix_set(kls->name, kls->eo_prefix);
+             database_class_eo_prefix_set(class, kls->eo_prefix);
           }
         if (kls->data_type)
           {
-             database_class_data_type_set(kls->name, kls->data_type);
+             database_class_data_type_set(class, kls->data_type);
           }
         EINA_LIST_FOREACH(kls->constructors, l, meth)
           {
              Eolian_Function foo_id = database_function_new(meth->name, EOLIAN_CTOR);
-             database_class_function_add(kls->name, foo_id);
+             database_class_function_add(class, foo_id);
              if (meth->ret) database_function_return_comment_set(foo_id, EOLIAN_METHOD, meth->ret->comment);
              database_function_data_set(foo_id, EOLIAN_LEGACY, meth->legacy);
              EINA_LIST_FOREACH(meth->params, m, param)
@@ -1480,14 +1480,14 @@ eo_tokenizer_database_fill(const char *filename)
                             }
                     }
                }
-             database_class_function_add(kls->name, foo_id);
+             database_class_function_add(class, foo_id);
           }
 
         EINA_LIST_FOREACH(kls->methods, l, meth)
           {
              Eolian_Function foo_id = database_function_new(meth->name, EOLIAN_METHOD);
              database_function_scope_set(foo_id, meth->scope);
-             database_class_function_add(kls->name, foo_id);
+             database_class_function_add(class, foo_id);
              if (meth->ret)
                {
                   Eolian_Type types = _types_extract(meth->ret->type, strlen(meth->ret->type));
@@ -1512,20 +1512,20 @@ eo_tokenizer_database_fill(const char *filename)
 
         EINA_LIST_FOREACH(kls->implements, l, impl)
           {
-             const char *class = impl->meth_name;
+             const char *impl_class = impl->meth_name;
              Eina_Bool virtual_pure = EINA_FALSE;
-             if (!strcmp(class, "class::constructor"))
+             if (!strcmp(impl_class, "class::constructor"))
                {
-                  database_class_ctor_enable_set(kls->name, EINA_TRUE);
+                  database_class_ctor_enable_set(class, EINA_TRUE);
                   continue;
                }
-             if (!strcmp(class, "class::destructor"))
+             if (!strcmp(impl_class, "class::destructor"))
                {
-                  database_class_dtor_enable_set(kls->name, EINA_TRUE);
+                  database_class_dtor_enable_set(class, EINA_TRUE);
                   continue;
                }
-             if (!strncmp(class, "virtual::", 9)) virtual_pure = EINA_TRUE;
-             char *func = strstr(class, "::");
+             if (!strncmp(impl_class, "virtual::", 9)) virtual_pure = EINA_TRUE;
+             char *func = strstr(impl_class, "::");
              if (func) *func = '\0';
              func += 2;
              Eolian_Function_Type ftype = EOLIAN_UNRESOLVED;
@@ -1540,23 +1540,23 @@ eo_tokenizer_database_fill(const char *filename)
                {
                   /* Search the function into the existing functions of the current class */
                   Eolian_Function foo_id = eolian_class_function_find_by_name(
-                        kls->name, func, ftype);
+                        class, func, ftype);
                   if (!foo_id)
                     {
-                       ERR("Error - %s not known in class %s", class + 9, kls->name);
+                       ERR("Error - %s not known in class %s", impl_class + 9, eolian_class_name_get(class));
                        goto end;
                     }
                   database_function_set_as_virtual_pure(foo_id, ftype);
                   continue;
                }
-             Eolian_Implement impl_desc = database_implement_new(class, func, ftype);
-             database_class_implement_add(kls->name, impl_desc);
+             Eolian_Implement impl_desc = database_implement_new(impl_class, func, ftype);
+             database_class_implement_add(class, impl_desc);
           }
 
         EINA_LIST_FOREACH(kls->events, l, event)
           {
              Eolian_Event ev = database_event_new(event->name, event->type, event->comment);
-             database_class_event_add(kls->name, ev);
+             database_class_event_add(class, ev);
           }
 
      }
diff --git a/src/lib/eolian/eolian_database.c b/src/lib/eolian/eolian_database.c
index 789d6b416b..b61f8be1a8 100644
--- a/src/lib/eolian/eolian_database.c
+++ b/src/lib/eolian/eolian_database.c
@@ -14,7 +14,7 @@
 #define EOLIAN_PROP_GET_RETURN_COMMENT "property_get_return_comment"
 #define EOLIAN_PROP_SET_RETURN_COMMENT "property_set_return_comment"
 
-static Eina_Hash *_classes = NULL;
+static Eina_List *_classes = NULL;
 static Eina_Hash *_types = NULL;
 static Eina_Hash *_filenames = NULL; /* Hash: filename without extension -> full path */
 static int _database_init_count = 0;
@@ -36,7 +36,7 @@ typedef struct
    Eina_List *events; /* List event_name -> _Event_Desc */
    Eina_Bool class_ctor_enable:1;
    Eina_Bool class_dtor_enable:1;
-} Class_desc;
+} _Class_Desc;
 
 typedef struct
 {
@@ -146,7 +146,7 @@ _fid_del(_Function_Id *fid)
 }
 
 static void
-_class_del(Class_desc *class)
+_class_del(_Class_Desc *class)
 {
    Eina_Stringshare *inherit_name;
    Eina_List *inherits = class->inherits;
@@ -178,12 +178,6 @@ _class_del(Class_desc *class)
    free(class);
 }
 
-static void _class_hash_free_cb(void *data)
-{
-   Class_desc *cl = data;
-   _class_del(cl);
-}
-
 static void _type_hash_free_cb(void *data)
 {
    Type_Desc *type = data;
@@ -192,22 +186,11 @@ static void _type_hash_free_cb(void *data)
    free(type);
 }
 
-static Class_desc *
-_class_get(const char *class_name)
-{
-   Eina_Stringshare *shr = eina_stringshare_add(class_name);
-   Class_desc *cl = eina_hash_find(_classes, shr);
-   eina_stringshare_del(shr);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(class_name, NULL);
-   return cl;
-}
-
 int
 database_init()
 {
    if (_database_init_count > 0) return ++_database_init_count;
    eina_init();
-   _classes = eina_hash_stringshared_new(_class_hash_free_cb);
    _types = eina_hash_stringshared_new(_type_hash_free_cb);
    _filenames = eina_hash_string_small_new(free);
    return ++_database_init_count;
@@ -225,7 +208,9 @@ database_shutdown()
 
    if (_database_init_count == 0)
      {
-        eina_hash_free(_classes);
+        Eolian_Class class;
+        EINA_LIST_FREE(_classes, class)
+           _class_del((_Class_Desc *)class);
         eina_hash_free(_types);
         eina_hash_free(_filenames);
         eina_shutdown();
@@ -257,49 +242,69 @@ eolian_type_find_by_alias(const char *alias)
    return cl->type;
 }
 
-Eina_Bool
+Eolian_Class
 database_class_add(const char *class_name, Eolian_Class_Type type)
 {
-   if (_classes)
-     {
-        Class_desc *desc = calloc(1, sizeof(*desc));
-        desc->name = eina_stringshare_add(class_name);
-        desc->type = type;
-        eina_hash_set(_classes, desc->name, desc);
-     }
-   return EINA_TRUE;
+   _Class_Desc *cl = NULL;
+   cl = calloc(1, sizeof(*cl));
+   cl->name = eina_stringshare_add(class_name);
+   cl->type = type;
+   _classes = eina_list_append(_classes, cl);
+   return (Eolian_Class)cl;
 }
 
 Eina_Bool
-database_class_file_set(const char *class_name, const char *file_name)
+database_class_file_set(Eolian_Class class, const char *file_name)
 {
-   Class_desc *cl = _class_get(class_name);
+   _Class_Desc *cl = (_Class_Desc *)class;
    EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
    cl->file = eina_stringshare_add(file_name);
    return EINA_TRUE;
 }
 
 EAPI const char *
-eolian_class_file_get(const char *class_name)
+eolian_class_file_get(const Eolian_Class class)
 {
-   Class_desc *cl = _class_get(class_name);
+   _Class_Desc *cl = (_Class_Desc *)class;
    return cl ? cl->file : NULL;
 }
 
 EAPI const char *
+eolian_class_name_get(const Eolian_Class class)
+{
+   _Class_Desc *cl = (_Class_Desc *)class;
+   return cl ? cl->name : NULL;
+}
+
+EAPI Eolian_Class
+eolian_class_find_by_name(const char *class_name)
+{
+   Eina_List *itr;
+   _Class_Desc *cl;
+   Eina_Stringshare *shr_name = eina_stringshare_add(class_name);
+   EINA_LIST_FOREACH(_classes, itr, cl)
+     {
+        if (cl->name == shr_name)
+          {
+             eina_stringshare_del(shr_name);
+             return (Eolian_Class)cl;
+          }
+     }
+   return NULL;
+}
+
+EAPI Eolian_Class
 eolian_class_find_by_file(const char *file_name)
 {
-   const Eina_List *names_list = eolian_class_names_list_get();
-   const Eina_List *itr;
-   const char *class_name;
+   Eina_List *itr;
+   _Class_Desc *cl;
    Eina_Stringshare *shr_file = eina_stringshare_add(file_name);
-   EINA_LIST_FOREACH(names_list, itr, class_name)
+   EINA_LIST_FOREACH(_classes, itr, cl)
      {
-        Class_desc *cl = _class_get(class_name);
         if (cl->file == shr_file)
           {
              eina_stringshare_del(shr_file);
-             return class_name;
+             return (Eolian_Class)cl;
           }
      }
    eina_stringshare_del(shr_file);
@@ -307,133 +312,122 @@ eolian_class_find_by_file(const char *file_name)
 }
 
 EAPI Eolian_Class_Type
-eolian_class_type_get(const char *class_name)
+eolian_class_type_get(const Eolian_Class class)
 {
-   Class_desc *cl = _class_get(class_name);
+   _Class_Desc *cl = (_Class_Desc *)class;
    EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EOLIAN_CLASS_UNKNOWN_TYPE);
    return cl->type;
 }
 
 Eina_Bool
-database_class_del(const char *class_name)
+database_class_del(Eolian_Class class)
 {
-   Class_desc *cl = _class_get(class_name);
+   _Class_Desc *cl = (_Class_Desc *)class;
    EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
-   eina_hash_del(_classes, class_name, NULL);
+   _classes = eina_list_remove(_classes, class);
    _class_del(cl);
    return EINA_TRUE;
 }
 
-static Eina_Bool _class_name_get(const Eina_Hash *hash EINA_UNUSED, const void *key EINA_UNUSED, void *data, void *fdata)
-{
-   Class_desc *desc = data;
-   Eina_List **list = fdata;
-   EINA_SAFETY_ON_FALSE_RETURN_VAL(desc && list , EINA_FALSE);
-   *list = eina_list_append(*list, desc->name);
-   return EINA_TRUE;
-}
-
 EAPI const Eina_List *
 eolian_class_names_list_get(void)
 {
+   Eina_List *itr;
+   _Class_Desc *cl;
    Eina_List *list = NULL;
-   eina_hash_foreach(_classes, _class_name_get, &list);
+   EINA_LIST_FOREACH(_classes, itr, cl)
+      list = eina_list_append(list, cl->name);
    return list;
 }
 
-EAPI Eina_Bool
-eolian_class_exists(const char *class_name)
-{
-   return !!_class_get(class_name);
-}
-
 Eina_Bool
-database_class_inherit_add(const char *class_name, const char *inherit_class_name)
+database_class_inherit_add(Eolian_Class class, const char *inherit_class_name)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE);
-   desc->inherits = eina_list_append(desc->inherits, eina_stringshare_add(inherit_class_name));
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
+   cl->inherits = eina_list_append(cl->inherits, eina_stringshare_add(inherit_class_name));
    return EINA_TRUE;
 }
 
 EAPI const char *
-eolian_class_description_get(const char *class_name)
+eolian_class_description_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
-   return desc->description;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
+   return cl->description;
 }
 
 void
-database_class_description_set(const char *class_name, const char *description)
+database_class_description_set(Eolian_Class class, const char *description)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN(desc);
-   desc->description = eina_stringshare_add(description);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN(cl);
+   cl->description = eina_stringshare_add(description);
 }
 
 EAPI const char*
-eolian_class_legacy_prefix_get(const char *class_name)
+eolian_class_legacy_prefix_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
-   return desc->legacy_prefix;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
+   return cl->legacy_prefix;
 }
 
 void
-database_class_legacy_prefix_set(const char *class_name, const char *legacy_prefix)
+database_class_legacy_prefix_set(Eolian_Class class, const char *legacy_prefix)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN(desc);
-   desc->legacy_prefix = eina_stringshare_add(legacy_prefix);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN(cl);
+   cl->legacy_prefix = eina_stringshare_add(legacy_prefix);
 }
 
 EAPI const char*
-eolian_class_eo_prefix_get(const char *class_name)
+eolian_class_eo_prefix_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
-   return desc->eo_prefix;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
+   return cl->eo_prefix;
 }
 
 void
-database_class_eo_prefix_set(const char *class_name, const char *eo_prefix)
+database_class_eo_prefix_set(Eolian_Class class, const char *eo_prefix)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN(desc);
-   desc->eo_prefix = eina_stringshare_add(eo_prefix);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN(cl);
+   cl->eo_prefix = eina_stringshare_add(eo_prefix);
 }
 
 EAPI const char*
-eolian_class_data_type_get(const char *class_name)
+eolian_class_data_type_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
-   return desc->data_type;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
+   return cl->data_type;
 }
 
 void
-database_class_data_type_set(const char *class_name, const char *data_type)
+database_class_data_type_set(Eolian_Class class, const char *data_type)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN(desc);
-   desc->data_type= eina_stringshare_add(data_type);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN(cl);
+   cl->data_type= eina_stringshare_add(data_type);
 }
 
 EAPI const Eina_List *
-eolian_class_inherits_list_get(const char *class_name)
+eolian_class_inherits_list_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
-   return desc->inherits;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
+   //FIXME: create list here
+   return cl->inherits;
 }
 
 EAPI const Eina_List*
-eolian_class_implements_list_get(const char *class_name)
+eolian_class_implements_list_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
-   return desc->implements;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
+   return cl->implements;
 }
 
 Eolian_Function
@@ -442,7 +436,7 @@ database_function_new(const char *function_name, Eolian_Function_Type foo_type)
    _Function_Id *fid = calloc(1, sizeof(*fid));
    fid->name = eina_stringshare_add(function_name);
    fid->type = foo_type;
-   fid->data  = eina_hash_string_superfast_new(free);
+   fid->data = eina_hash_string_superfast_new(free);
    return (Eolian_Function) fid;
 }
 
@@ -481,24 +475,24 @@ database_function_type_set(Eolian_Function function_id, Eolian_Function_Type foo
    fid->type = foo_type;
 }
 
-Eina_Bool database_class_function_add(const char *class_name, Eolian_Function foo_id)
+Eina_Bool database_class_function_add(Eolian_Class class, Eolian_Function foo_id)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE);
-   EINA_SAFETY_ON_FALSE_RETURN_VAL(foo_id && desc, EINA_FALSE);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
+   EINA_SAFETY_ON_FALSE_RETURN_VAL(foo_id && cl, EINA_FALSE);
    _Function_Id *fid = (_Function_Id *) foo_id;
    switch (fid->type)
      {
       case EOLIAN_PROPERTY:
       case EOLIAN_PROP_SET:
       case EOLIAN_PROP_GET:
-         desc->properties = eina_list_append(desc->properties, foo_id);
+         cl->properties = eina_list_append(cl->properties, foo_id);
          break;
       case EOLIAN_METHOD:
-         desc->methods = eina_list_append(desc->methods, foo_id);
+         cl->methods = eina_list_append(cl->methods, foo_id);
          break;
       case EOLIAN_CTOR:
-         desc->constructors = eina_list_append(desc->constructors, foo_id);
+         cl->constructors = eina_list_append(cl->constructors, foo_id);
          break;
       default:
          ERR("Bad function type %d.", fid->type);
@@ -520,12 +514,12 @@ database_implement_new(const char *class_name, const char *func_name, Eolian_Fun
 }
 
 Eina_Bool
-database_class_implement_add(const char *class_name, Eolian_Implement impl_desc)
+database_class_implement_add(Eolian_Class class, Eolian_Implement impl_desc)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(impl_desc, EINA_FALSE);
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE);
-   desc->implements = eina_list_append(desc->implements, impl_desc);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
+   cl->implements = eina_list_append(cl->implements, impl_desc);
    return EINA_TRUE;
 }
 
@@ -541,15 +535,15 @@ eolian_implement_information_get(Eolian_Implement impl, const char **class_name,
 }
 
 EAPI Eolian_Function
-eolian_class_function_find_by_name(const char *class_name, const char *func_name, Eolian_Function_Type f_type)
+eolian_class_function_find_by_name(const Eolian_Class class, const char *func_name, Eolian_Function_Type f_type)
 {
    Eina_List *itr;
    Eolian_Function foo_id;
-   Class_desc *desc = _class_get(class_name);
-   if (!desc) return NULL;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   if (!cl) return NULL;
 
    if (f_type == EOLIAN_UNRESOLVED || f_type == EOLIAN_METHOD)
-      EINA_LIST_FOREACH(desc->methods, itr, foo_id)
+      EINA_LIST_FOREACH(cl->methods, itr, foo_id)
         {
            _Function_Id *fid = (_Function_Id *) foo_id;
            if (!strcmp(fid->name, func_name))
@@ -559,7 +553,7 @@ eolian_class_function_find_by_name(const char *class_name, const char *func_name
    if (f_type == EOLIAN_UNRESOLVED || f_type == EOLIAN_PROPERTY ||
          f_type == EOLIAN_PROP_SET || f_type == EOLIAN_PROP_GET)
      {
-        EINA_LIST_FOREACH(desc->properties, itr, foo_id)
+        EINA_LIST_FOREACH(cl->properties, itr, foo_id)
           {
              _Function_Id *fid = (_Function_Id *) foo_id;
              if (!strcmp(fid->name, func_name))
@@ -569,7 +563,7 @@ eolian_class_function_find_by_name(const char *class_name, const char *func_name
 
    if (f_type == EOLIAN_UNRESOLVED || f_type == EOLIAN_CTOR)
      {
-        EINA_LIST_FOREACH(desc->constructors, itr, foo_id)
+        EINA_LIST_FOREACH(cl->constructors, itr, foo_id)
           {
              _Function_Id *fid = (_Function_Id *) foo_id;
              if (!strcmp(fid->name, func_name))
@@ -577,23 +571,23 @@ eolian_class_function_find_by_name(const char *class_name, const char *func_name
           }
      }
 
-   ERR("Function %s not found in class %s", func_name, class_name);
+   ERR("Function %s not found in class %s", func_name, cl->name);
    return NULL;
 }
 
 EAPI const Eina_List *
-eolian_class_functions_list_get(const char *class_name, Eolian_Function_Type foo_type)
+eolian_class_functions_list_get(const Eolian_Class class, Eolian_Function_Type foo_type)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
    switch (foo_type)
      {
       case EOLIAN_PROPERTY:
-         return desc->properties;
+         return cl->properties;
       case EOLIAN_METHOD:
-         return desc->methods;
+         return cl->methods;
       case EOLIAN_CTOR:
-         return desc->constructors;
+         return cl->constructors;
       default: return NULL;
      }
 }
@@ -1000,20 +994,20 @@ database_event_free(Eolian_Event event)
 }
 
 Eina_Bool
-database_class_event_add(const char *class_name, Eolian_Event event_desc)
+database_class_event_add(Eolian_Class class, Eolian_Event event_desc)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_FALSE_RETURN_VAL(event_desc && desc, EINA_FALSE);
-   desc->events = eina_list_append(desc->events, event_desc);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_FALSE_RETURN_VAL(event_desc && cl, EINA_FALSE);
+   cl->events = eina_list_append(cl->events, event_desc);
    return EINA_TRUE;
 }
 
 EAPI const Eina_List*
-eolian_class_events_list_get(const char *class_name)
+eolian_class_events_list_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
-   return desc->events;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, NULL);
+   return cl->events;
 }
 
 EAPI Eina_Bool
@@ -1028,37 +1022,37 @@ eolian_class_event_information_get(Eolian_Event event, const char **event_name,
 }
 
 Eina_Bool
-database_class_ctor_enable_set(const char *class_name, Eina_Bool enable)
+database_class_ctor_enable_set(Eolian_Class class, Eina_Bool enable)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE);
-   desc->class_ctor_enable = enable;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
+   cl->class_ctor_enable = enable;
    return EINA_TRUE;
 }
 
 Eina_Bool
-database_class_dtor_enable_set(const char *class_name, Eina_Bool enable)
+database_class_dtor_enable_set(Eolian_Class class, Eina_Bool enable)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE);
-   desc->class_dtor_enable = enable;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
+   cl->class_dtor_enable = enable;
    return EINA_TRUE;
 }
 
 EAPI Eina_Bool
-eolian_class_ctor_enable_get(const char *class_name)
+eolian_class_ctor_enable_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE);
-   return desc->class_ctor_enable;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
+   return cl->class_ctor_enable;
 }
 
 EAPI Eina_Bool
-eolian_class_dtor_enable_get(const char *class_name)
+eolian_class_dtor_enable_get(const Eolian_Class class)
 {
-   Class_desc *desc = _class_get(class_name);
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE);
-   return desc->class_dtor_enable;
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
+   return cl->class_dtor_enable;
 }
 
 static void
@@ -1202,26 +1196,27 @@ static Eina_Bool _function_print(const _Function_Id *fid, int nb_spaces)
    return EINA_TRUE;
 }
 
-static Eina_Bool _class_print(const Eina_Hash *hash EINA_UNUSED, const void *key EINA_UNUSED, void *data, void *fdata EINA_UNUSED)
+static Eina_Bool
+_class_print(const Eolian_Class class)
 {
    Eina_List *itr;
    _Function_Id *function;
    const char *types[5] = {"", "Regular", "Regular Non Instantiable", "Mixin", "Interface"};
 
-   Class_desc *desc = data;
-   EINA_SAFETY_ON_NULL_RETURN_VAL(desc, EINA_FALSE);
-   printf("Class %s:\n", desc->name);
-   if (desc->description)
-      printf("  description: <%s>\n", desc->description);
+   _Class_Desc *cl = (_Class_Desc *)class;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(cl, EINA_FALSE);
+   printf("Class %s:\n", cl->name);
+   if (cl->description)
+      printf("  description: <%s>\n", cl->description);
 
-   printf("  type: %s\n", types[desc->type]);
+   printf("  type: %s\n", types[cl->type]);
 
    // Inherits
-   if (desc->inherits)
+   if (cl->inherits)
      {
         printf("  inherits: ");
         char *word;
-        EINA_LIST_FOREACH(desc->inherits, itr, word)
+        EINA_LIST_FOREACH(cl->inherits, itr, word)
           {
              printf("%s ", word);
           }
@@ -1229,26 +1224,26 @@ static Eina_Bool _class_print(const Eina_Hash *hash EINA_UNUSED, const void *key
      }
 
    // Legacy prefix
-   if (desc->legacy_prefix)
+   if (cl->legacy_prefix)
      {
-        printf("  legacy prefix: <%s>\n", desc->legacy_prefix);
+        printf("  legacy prefix: <%s>\n", cl->legacy_prefix);
      }
 
    // Eo prefix
-   if (desc->eo_prefix)
+   if (cl->eo_prefix)
      {
-        printf("  Eo prefix: <%s>\n", desc->eo_prefix);
+        printf("  Eo prefix: <%s>\n", cl->eo_prefix);
      }
 
    // Data type
-   if (desc->data_type)
+   if (cl->data_type)
      {
-        printf("  Data type: <%s>\n", desc->data_type);
+        printf("  Data type: <%s>\n", cl->data_type);
      }
 
    // Constructors
    printf("  constructors:\n");
-   EINA_LIST_FOREACH(desc->constructors, itr, function)
+   EINA_LIST_FOREACH(cl->constructors, itr, function)
      {
         _function_print(function, 4);
      }
@@ -1256,7 +1251,7 @@ static Eina_Bool _class_print(const Eina_Hash *hash EINA_UNUSED, const void *key
 
    // Properties
    printf("  properties:\n");
-   EINA_LIST_FOREACH(desc->properties, itr, function)
+   EINA_LIST_FOREACH(cl->properties, itr, function)
      {
         _function_print(function, 4);
      }
@@ -1264,14 +1259,14 @@ static Eina_Bool _class_print(const Eina_Hash *hash EINA_UNUSED, const void *key
 
    // Methods
    printf("  methods:\n");
-   EINA_LIST_FOREACH(desc->methods, itr, function)
+   EINA_LIST_FOREACH(cl->methods, itr, function)
      {
         _function_print(function, 4);
      }
    // Implement
    printf("  implements:\n");
    Eolian_Implement impl;
-   EINA_LIST_FOREACH((Eina_List *) eolian_class_implements_list_get(desc->name), itr, impl)
+   EINA_LIST_FOREACH(cl->implements, itr, impl)
      {
         _implements_print(impl, 4);
      }
@@ -1279,7 +1274,7 @@ static Eina_Bool _class_print(const Eina_Hash *hash EINA_UNUSED, const void *key
    // Implement
    printf("  events:\n");
    Eolian_Event ev;
-   EINA_LIST_FOREACH((Eina_List *) eolian_class_events_list_get(desc->name), itr, ev)
+   EINA_LIST_FOREACH(cl->events, itr, ev)
      {
         _event_print(ev, 4);
      }
@@ -1288,14 +1283,18 @@ static Eina_Bool _class_print(const Eina_Hash *hash EINA_UNUSED, const void *key
 }
 
 EAPI Eina_Bool
-eolian_show(const char *class_name)
+eolian_show(const Eolian_Class class)
 {
-   if (!class_name)
-      eina_hash_foreach(_classes, _class_print, NULL);
+   if (!class)
+     {
+        Eina_List *itr;
+        Eolian_Class cl;
+        EINA_LIST_FOREACH(_classes, itr, cl)
+           _class_print(cl);
+     }
    else
      {
-        Class_desc *klass = _class_get(class_name);
-        _class_print(NULL, NULL, klass, NULL);
+        _class_print(class);
      }
    return EINA_TRUE;
 }
@@ -1325,20 +1324,20 @@ eolian_directory_scan(const char *dir)
 EAPI Eina_Bool eolian_eo_file_parse(const char *filepath)
 {
    const Eina_List *itr;
-   const char *class_name = eolian_class_find_by_file(filepath);
+   Eolian_Class class = eolian_class_find_by_file(filepath);
    const char *inherit_name;
    Eolian_Implement impl;
-   if (!class_name)
+   if (!class)
      {
         if (!eo_tokenizer_database_fill(filepath)) return EINA_FALSE;
-        class_name = eolian_class_find_by_file(filepath);
-        if (!class_name)
+        class = eolian_class_find_by_file(filepath);
+        if (!class)
           {
              ERR("No class for file %s", filepath);
              return EINA_FALSE;
           }
      }
-   EINA_LIST_FOREACH(eolian_class_inherits_list_get(class_name), itr, inherit_name)
+   EINA_LIST_FOREACH(eolian_class_inherits_list_get(class), itr, inherit_name)
      {
         if (!eolian_class_exists(inherit_name))
           {
@@ -1354,10 +1353,11 @@ EAPI Eina_Bool eolian_eo_file_parse(const char *filepath)
              free(filename);
           }
      }
-   EINA_LIST_FOREACH(eolian_class_implements_list_get(class_name), itr, impl)
+   EINA_LIST_FOREACH(eolian_class_implements_list_get(class), itr, impl)
      {
         _Implement_Desc *_impl = (_Implement_Desc *)impl;
-        Eolian_Function foo = eolian_class_function_find_by_name(_impl->class_name, _impl->func_name, _impl->type);
+        Eolian_Class impl_class = eolian_class_find_by_name(_impl->class_name);
+        Eolian_Function foo = eolian_class_function_find_by_name(impl_class, _impl->func_name, _impl->type);
         if (!foo)
           {
              ERR("Unable to find function %s in class %s", _impl->func_name, _impl->class_name);
diff --git a/src/lib/eolian/eolian_database.h b/src/lib/eolian/eolian_database.h
index 113d0de9c5..c30351c22e 100644
--- a/src/lib/eolian/eolian_database.h
+++ b/src/lib/eolian/eolian_database.h
@@ -37,34 +37,34 @@ int database_shutdown();
 Eina_Bool database_type_add(const char *alias, Eolian_Type type);
 
 /* Add a class in the database */
-Eina_Bool database_class_add(const char *class_name, Eolian_Class_Type type);
+Eolian_Class database_class_add(const char *class_name, Eolian_Class_Type type);
 
 /* Add a class from the database */
 Eina_Bool
-database_class_del(const char *class_name);
+database_class_del(Eolian_Class class);
 
 /* Add an inherit class name to a class */
-Eina_Bool database_class_inherit_add(const char *class_name, const char *inherit_class_name);
+Eina_Bool database_class_inherit_add(Eolian_Class class, const char *inherit_class_name);
 
 /* Set description of class. */
 void
-database_class_description_set(const char *class_name, const char *description);
+database_class_description_set(Eolian_Class class, const char *description);
 
 /* Set legacy of class. */
 void
-database_class_legacy_prefix_set(const char *class_name, const char *legacy_prefix);
+database_class_legacy_prefix_set(Eolian_Class class, const char *legacy_prefix);
 
 /* Set eo prefix of class. */
 void
-database_class_eo_prefix_set(const char *class_name, const char *eo_prefix);
+database_class_eo_prefix_set(Eolian_Class class, const char *eo_prefix);
 
 /* Set data of class. */
 void
-database_class_data_type_set(const char *class_name, const char *data_type);
+database_class_data_type_set(Eolian_Class class, const char *data_type);
 
 /* Set file of class */
 Eina_Bool
-database_class_file_set(const char *class_name, const char *file_name);
+database_class_file_set(Eolian_Class class, const char *file_name);
 
 /* Create a function */
 Eolian_Function database_function_new(const char *function_name, Eolian_Function_Type foo_type);
@@ -73,7 +73,7 @@ Eolian_Function database_function_new(const char *function_name, Eolian_Function
 void database_function_type_set(Eolian_Function function_id, Eolian_Function_Type foo_type);
 
 /* Add a function to a class */
-Eina_Bool database_class_function_add(const char *classname, Eolian_Function foo_id);
+Eina_Bool database_class_function_add(Eolian_Class class, Eolian_Function foo_id);
 
 void database_function_data_set(Eolian_Function function_id, const char *key, const char *description);
 
@@ -120,13 +120,13 @@ Eolian_Implement
 database_implement_new(const char *class_name, const char *func_name, Eolian_Function_Type type);
 
 Eina_Bool
-database_class_implement_add(const char *class_name, Eolian_Implement impl_id);
+database_class_implement_add(Eolian_Class class, Eolian_Implement impl_id);
 
 Eina_Bool
-database_class_ctor_enable_set(const char *class_name, Eina_Bool enable);
+database_class_ctor_enable_set(Eolian_Class class, Eina_Bool enable);
 
 Eina_Bool
-database_class_dtor_enable_set(const char *class_name, Eina_Bool enable);
+database_class_dtor_enable_set(Eolian_Class class, Eina_Bool enable);
 
 Eolian_Event
 database_event_new(const char *event_name, const char *event_type, const char *event_desc);
@@ -135,6 +135,6 @@ void
 database_event_free(Eolian_Event event);
 
 Eina_Bool
-database_class_event_add(const char *class_name, Eolian_Event event_desc);
+database_class_event_add(Eolian_Class class, Eolian_Event event_desc);
 
 #endif
diff --git a/src/tests/eolian/eolian_parsing.c b/src/tests/eolian/eolian_parsing.c
index 7ad4baf9bd..26730d1ce4 100644
--- a/src/tests/eolian/eolian_parsing.c
+++ b/src/tests/eolian/eolian_parsing.c
@@ -12,10 +12,9 @@
 START_TEST(eolian_override)
 {
    Eolian_Function fid = NULL;
-   const char *class_name = "Simple";
-   const char *base_name = "Base";
    const Eina_List *impls = NULL;
    const char *impl_class = NULL, *impl_func = NULL;
+   Eolian_Class class, base;
 
    eolian_init();
    /* Parsing */
@@ -23,23 +22,24 @@ START_TEST(eolian_override)
    fail_if(!eolian_eo_file_parse(PACKAGE_DATA_DIR"/data/override.eo"));
 
    /* Class */
-   fail_if(!eolian_class_exists(class_name));
+   fail_if(!(class = eolian_class_find_by_name("Simple")));
+   fail_if(!(base = eolian_class_find_by_name("Base")));
 
    /* Base ctor */
-   fail_if(!(fid = eolian_class_function_find_by_name(base_name, "constructor", EOLIAN_UNRESOLVED)));
+   fail_if(!(fid = eolian_class_function_find_by_name(base, "constructor", EOLIAN_UNRESOLVED)));
    fail_if(!eolian_function_is_virtual_pure(fid, EOLIAN_UNRESOLVED));
-   fail_if(!(impls = eolian_class_implements_list_get(class_name)));
+   fail_if(!(impls = eolian_class_implements_list_get(class)));
    fail_if(!eolian_implement_information_get(eina_list_nth(impls, 0), &impl_class, &impl_func, NULL));
-   fail_if(strcmp(impl_class, base_name));
+   fail_if(strcmp(impl_class, "Base"));
    fail_if(strcmp(impl_func, "constructor"));
 
    /* Property */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "a", EOLIAN_PROPERTY)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "a", EOLIAN_PROPERTY)));
    fail_if(!eolian_function_is_virtual_pure(fid, EOLIAN_PROP_SET));
    fail_if(eolian_function_is_virtual_pure(fid, EOLIAN_PROP_GET));
 
    /* Method */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "foo", EOLIAN_METHOD)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "foo", EOLIAN_METHOD)));
    fail_if(!eolian_function_is_virtual_pure(fid, EOLIAN_METHOD));
 
    eolian_shutdown();
@@ -49,24 +49,22 @@ END_TEST
 START_TEST(eolian_consts)
 {
    Eolian_Function fid = NULL;
-   const char *class_name = "Const";
    Eolian_Function_Parameter param = NULL;
+   Eolian_Class class;
 
    eolian_init();
    /* Parsing */
    fail_if(!eolian_eo_file_parse(PACKAGE_DATA_DIR"/data/consts.eo"));
-
-   /* Class */
-   fail_if(!eolian_class_exists(class_name));
+   fail_if(!(class = eolian_class_find_by_name("Const")));
 
    /* Property */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "a", EOLIAN_PROPERTY)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "a", EOLIAN_PROPERTY)));
    fail_if(!(param = eolian_function_parameter_get(fid, "buffer")));
    fail_if(eolian_parameter_const_attribute_get(param, EINA_FALSE));
    fail_if(!eolian_parameter_const_attribute_get(param, EINA_TRUE));
 
    /* Method */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "foo", EOLIAN_METHOD)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "foo", EOLIAN_METHOD)));
    fail_if(EINA_FALSE == eolian_function_object_is_const(fid));
 
    eolian_shutdown();
@@ -75,35 +73,36 @@ END_TEST
 
 START_TEST(eolian_ctor_dtor)
 {
-   const char *class_name = "Ctor_Dtor";
-   const char *base_name = "Base";
    const Eina_List *impls = NULL;
    const char *impl_class = NULL, *impl_func = NULL;
+   Eolian_Class class, base;
 
    eolian_init();
    /* Parsing */
    fail_if(!eolian_directory_scan(PACKAGE_DATA_DIR"/data"));
    fail_if(!eolian_eo_file_parse(PACKAGE_DATA_DIR"/data/ctor_dtor.eo"));
+   fail_if(!(class = eolian_class_find_by_name("Ctor_Dtor")));
+   fail_if(!(base = eolian_class_find_by_name("Base")));
 
    /* Class ctor/dtor */
-   fail_if(!eolian_class_ctor_enable_get(class_name));
-   fail_if(!eolian_class_dtor_enable_get(class_name));
+   fail_if(!eolian_class_ctor_enable_get(class));
+   fail_if(!eolian_class_dtor_enable_get(class));
 
    /* Base ctor/dtor */
-   fail_if(!(impls = eolian_class_implements_list_get(class_name)));
+   fail_if(!(impls = eolian_class_implements_list_get(class)));
    fail_if(eina_list_count(impls) != 2);
    fail_if(!eolian_implement_information_get(eina_list_nth(impls, 0), &impl_class, &impl_func, NULL));
-   fail_if(strcmp(impl_class, base_name));
+   fail_if(strcmp(impl_class, "Base"));
    fail_if(strcmp(impl_func, "constructor"));
    fail_if(!eolian_implement_information_get(eina_list_nth(impls, 1), &impl_class, &impl_func, NULL));
-   fail_if(strcmp(impl_class, base_name));
+   fail_if(strcmp(impl_class, "Base"));
    fail_if(strcmp(impl_func, "destructor"));
 
    /* Custom ctors/dtors */
-   fail_if(!eolian_class_function_find_by_name(base_name, "constructor", EOLIAN_METHOD));
-   fail_if(!eolian_class_function_find_by_name(base_name, "destructor", EOLIAN_METHOD));
-   fail_if(!eolian_class_function_find_by_name(class_name, "custom_constructor_1", EOLIAN_CTOR));
-   fail_if(!eolian_class_function_find_by_name(class_name, "custom_constructor_2", EOLIAN_CTOR));
+   fail_if(!eolian_class_function_find_by_name(base, "constructor", EOLIAN_METHOD));
+   fail_if(!eolian_class_function_find_by_name(base, "destructor", EOLIAN_METHOD));
+   fail_if(!eolian_class_function_find_by_name(class, "custom_constructor_1", EOLIAN_CTOR));
+   fail_if(!eolian_class_function_find_by_name(class, "custom_constructor_2", EOLIAN_CTOR));
 
    eolian_shutdown();
 }
@@ -114,13 +113,15 @@ START_TEST(eolian_typedef)
    Eolian_Type types_list = NULL;
    const char *type_name = NULL;
    Eina_Bool own = EINA_FALSE;
+   Eolian_Class class;
 
    eolian_init();
    /* Parsing */
    fail_if(!eolian_eo_file_parse(PACKAGE_DATA_DIR"/data/typedef.eo"));
 
    /* Check that the class Dummy is still readable */
-   fail_if(!eolian_class_function_find_by_name("Dummy", "foo", EOLIAN_METHOD));
+   fail_if(!(class = eolian_class_find_by_name("Dummy")));
+   fail_if(!eolian_class_function_find_by_name(class, "foo", EOLIAN_METHOD));
 
    /* Basic type */
    fail_if(!(types_list = eolian_type_find_by_alias("Evas_Coord")));
@@ -146,17 +147,18 @@ START_TEST(eolian_complex_type)
    Eolian_Function fid = NULL;
    Eolian_Function_Parameter param = NULL;
    const Eina_List *params_list = NULL;
-   const char *class_name = "Complex_Type";
    Eolian_Type types_list = NULL;
    const char *type_name = NULL;
    Eina_Bool own = EINA_FALSE;
+   Eolian_Class class;
 
    eolian_init();
    /* Parsing */
    fail_if(!eolian_eo_file_parse(PACKAGE_DATA_DIR"/data/complex_type.eo"));
+   fail_if(!(class = eolian_class_find_by_name("Complex_Type")));
 
    /* Properties return type */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "a", EOLIAN_PROPERTY)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "a", EOLIAN_PROPERTY)));
    fail_if(!(types_list = eolian_function_return_types_list_get(fid, EOLIAN_PROP_SET)));
    fail_if(!(types_list = eolian_type_information_get(types_list, &type_name, &own)));
    fail_if(strcmp(type_name, "Eina_List *"));
@@ -181,7 +183,7 @@ START_TEST(eolian_complex_type)
    fail_if(own != EINA_FALSE);
 
    /* Methods return type */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "foo", EOLIAN_METHOD)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "foo", EOLIAN_METHOD)));
    fail_if(!(types_list = eolian_function_return_types_list_get(fid, EOLIAN_METHOD)));
    fail_if(!(types_list = eolian_type_information_get(types_list, &type_name, &own)));
    fail_if(strcmp(type_name, "Eina_List *"));
@@ -206,26 +208,27 @@ END_TEST
 START_TEST(eolian_scope)
 {
    Eolian_Function fid = NULL;
-   const char *class_name = "Simple";
+   Eolian_Class class;
 
    eolian_init();
    /* Parsing */
    fail_if(!eolian_eo_file_parse(PACKAGE_DATA_DIR"/data/scope.eo"));
+   fail_if(!(class = eolian_class_find_by_name("Simple")));
 
    /* Property scope */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "a", EOLIAN_PROPERTY)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "a", EOLIAN_PROPERTY)));
    fail_if(eolian_function_scope_get(fid) != EOLIAN_SCOPE_PROTECTED);
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "b", EOLIAN_PROPERTY)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "b", EOLIAN_PROPERTY)));
    fail_if(eolian_function_scope_get(fid) != EOLIAN_SCOPE_PUBLIC);
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "c", EOLIAN_PROPERTY)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "c", EOLIAN_PROPERTY)));
    fail_if(eolian_function_scope_get(fid) != EOLIAN_SCOPE_PUBLIC);
 
    /* Method scope */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "foo", EOLIAN_METHOD)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "foo", EOLIAN_METHOD)));
    fail_if(eolian_function_scope_get(fid) != EOLIAN_SCOPE_PUBLIC);
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "bar", EOLIAN_METHOD)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "bar", EOLIAN_METHOD)));
    fail_if(eolian_function_scope_get(fid) != EOLIAN_SCOPE_PROTECTED);
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "foobar", EOLIAN_METHOD)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "foobar", EOLIAN_METHOD)));
    fail_if(eolian_function_scope_get(fid) != EOLIAN_SCOPE_PUBLIC);
 
    eolian_shutdown();
@@ -237,29 +240,29 @@ START_TEST(eolian_simple_parsing)
    Eolian_Function fid = NULL;
    const char *string = NULL, *ptype = NULL, *pname = NULL;
    Eolian_Parameter_Dir dir = EOLIAN_IN_PARAM;
-   const char *class_name = "Simple";
    const Eina_List *list = NULL;
    Eolian_Function_Parameter param = NULL;
+   Eolian_Class class;
 
    eolian_init();
    /* Parsing */
    fail_if(!eolian_eo_file_parse(PACKAGE_DATA_DIR"/data/class_simple.eo"));
-   fail_if(strcmp(eolian_class_find_by_file(PACKAGE_DATA_DIR"/data/class_simple.eo"), class_name));
-   fail_if(strcmp(eolian_class_file_get(class_name), PACKAGE_DATA_DIR"/data/class_simple.eo"));
+   fail_if(!(class = eolian_class_find_by_name("Simple")));
+   fail_if(eolian_class_find_by_file(PACKAGE_DATA_DIR"/data/class_simple.eo") != class);
+   fail_if(strcmp(eolian_class_file_get(class), PACKAGE_DATA_DIR"/data/class_simple.eo"));
 
    /* Class */
-   fail_if(!eolian_class_exists(class_name));
-   fail_if(eolian_class_type_get(class_name) != EOLIAN_CLASS_REGULAR);
-   string = eolian_class_description_get(class_name);
+   fail_if(eolian_class_type_get(class) != EOLIAN_CLASS_REGULAR);
+   string = eolian_class_description_get(class);
    fail_if(!string);
    fail_if(strcmp(string, "Class Desc Simple"));
-   fail_if(eolian_class_inherits_list_get(class_name) != NULL);
-   fail_if(strcmp(eolian_class_legacy_prefix_get(class_name), "evas_object_simple"));
-   fail_if(strcmp(eolian_class_eo_prefix_get(class_name), "evas_obj_simple"));
-   fail_if(strcmp(eolian_class_data_type_get(class_name), "Evas_Simple_Data"));
+   fail_if(eolian_class_inherits_list_get(class) != NULL);
+   fail_if(strcmp(eolian_class_legacy_prefix_get(class), "evas_object_simple"));
+   fail_if(strcmp(eolian_class_eo_prefix_get(class), "evas_obj_simple"));
+   fail_if(strcmp(eolian_class_data_type_get(class), "Evas_Simple_Data"));
 
    /* Property */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "a", EOLIAN_PROPERTY)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "a", EOLIAN_PROPERTY)));
    fail_if(strcmp(eolian_function_name_get(fid), "a"));
    string = eolian_function_description_get(fid, EOLIAN_COMMENT_SET);
    fail_if(!string);
@@ -293,7 +296,7 @@ START_TEST(eolian_simple_parsing)
    fail_if(strcmp(string, "Value description"));
 
    /* Method */
-   fail_if(!(fid = eolian_class_function_find_by_name(class_name, "foo", EOLIAN_METHOD)));
+   fail_if(!(fid = eolian_class_function_find_by_name(class, "foo", EOLIAN_METHOD)));
    string = eolian_function_description_get(fid, EOLIAN_COMMENT);
    fail_if(!string);
    fail_if(strcmp(string, "comment foo"));