lib/eo.c

   1 #include <Eina.h>
   2
   3 #include "Eo.h"
   4 #include "eo_private.h"
   5
   6 #include "config.h"
   7
   8 typedef size_t Eo_Class_Id;
   9
  10 /* Used inside the class_get functions of classes, see #EO_DEFINE_CLASS */
  11 EAPI Eina_Lock _eo_class_creation_lock;
  12 int _eo_log_dom = -1;
  13
  14 static Eo_Class **_eo_classes;
  15 static Eo_Class_Id _eo_classes_last_id;
  16 static Eina_Bool _eo_init_count = 0;
  17
  18 static void _eo_constructor(Eo *obj, const Eo_Class *klass);
  19 static void _eo_destructor(Eo *obj, const Eo_Class *klass);
  20 static inline Eina_Bool _eo_error_get(const Eo *obj);
  21 static inline void _eo_error_unset(Eo *obj);
  22 static inline void *_eo_data_get(const Eo *obj, const Eo_Class *klass);
  23 static inline Eo *_eo_ref(Eo *obj);
  24 static inline void _eo_unref(Eo *obj);
  25
  26 typedef struct
  27 {
  28    Eo_Op op;
  29    const Eo_Class **kls_itr;
  30 } Eo_Kls_Itr;
  31
  32 struct _Eo {
  33      EINA_MAGIC
  34      Eo *parent;
  35      const Eo_Class *klass;
  36      int refcount;
  37 #ifndef NDEBUG
  38      Eina_Inlist *xrefs;
  39 #endif
  40
  41      Eina_List *composite_objects;
  42
  43      Eo_Kls_Itr mro_itr;
  44
  45      Eina_Bool del:1;
  46      Eina_Bool construct_error:1;
  47 };
  48
  49 /* Start of Dich */
  50 /* Dich search, split to 0xff 0xff 0xffff */
  51
  52 #define DICH_CHAIN1_MASK (0xffff)
  53 #define DICH_CHAIN_LAST_MASK (0xffff)
  54 #define DICH_CHAIN1(x) (((x) >> 16) & DICH_CHAIN1_MASK)
  55 #define DICH_CHAIN_LAST(x) ((x) & DICH_CHAIN_LAST_MASK)
  56
  57 #define OP_CLASS_OFFSET 16
  58 #define OP_CLASS_OFFSET_GET(x) (((x) >> OP_CLASS_OFFSET) & 0xffff)
  59 #define OP_CLASS_GET(op) ({ \
  60       Eo_Class_Id tmp = OP_CLASS_OFFSET_GET(op); \
  61       ID_CLASS_GET(tmp); \
  62       })
  63 #define OP_SUB_ID_GET(op) ((op) & 0xffff)
  64
  65 #define ID_CLASS_GET(id) ({ \
  66       (Eo_Class *) ((id <= _eo_classes_last_id) && (id > 0)) ? \
  67       (_eo_classes[id - 1]) : NULL; \
  68       })
  69
  70 #define EO_ALIGN_SIZE(size) \
  71         ((size) + (sizeof(void *) - ((size) % sizeof(void *))))
  72
  73 /* Structure of Eo_Op is:
  74  * 16bit: class
  75  * 16bit: op.
  76  */
  77
  78 typedef struct _Dich_Chain1 Dich_Chain1;
  79
  80 typedef struct
  81 {
  82    eo_op_func_type func;
  83    const Eo_Class *src;
  84 } op_type_funcs;
  85
  86 struct _Dich_Chain1
  87 {
  88    op_type_funcs *funcs;
  89 };
  90
  91 typedef struct
  92 {
  93      EINA_INLIST;
  94      const Eo_Class *klass;
  95 } Eo_Extension_Node;
  96
  97 typedef struct
  98 {
  99      const Eo_Class *klass;
 100      size_t offset;
 101 } Eo_Extension_Data_Offset;
 102
 103 struct _Eo_Class
 104 {
 105    EINA_MAGIC
 106    Eo_Class_Id class_id;
 107    const Eo_Class *parent;
 108    const Eo_Class_Description *desc;
 109    Dich_Chain1 *chain; /**< The size is class_id */
 110    Eina_Inlist *extensions;
 111
 112    Eo_Extension_Data_Offset *extn_data_off;
 113    size_t extn_data_size;
 114
 115    const Eo_Class **mro;
 116    Eo_Kls_Itr mro_itr;
 117
 118    size_t data_offset; /* < Offset of the data within object data. */
 119
 120    Eina_Bool constructed : 1;
 121 };
 122
 123 static inline void
 124 _dich_chain_alloc(Dich_Chain1 *chain1, size_t num_ops)
 125 {
 126    if (!chain1->funcs)
 127      {
 128         chain1->funcs = calloc(num_ops, sizeof(*(chain1->funcs)));
 129      }
 130 }
 131
 132 static inline void
 133 _dich_copy_all(Eo_Class *dst, const Eo_Class *src)
 134 {
 135    if (!src->chain) return;
 136
 137    if (!dst->chain)
 138      {
 139         dst->chain = calloc(dst->class_id, sizeof(*dst->chain));
 140      }
 141
 142    Eo_Class_Id i;
 143    const Dich_Chain1 *sc1 = src->chain;
 144    Dich_Chain1 *dc1 = dst->chain;
 145    for (i = 0 ; i < src->class_id ; i++, sc1++, dc1++)
 146      {
 147         if (sc1->funcs)
 148           {
 149              size_t j;
 150              const Eo_Class *op_klass = ID_CLASS_GET(i + 1);
 151              /* Can be NULL because of future static classes. */
 152              if (!op_klass)
 153                 continue;
 154
 155              size_t num_ops = op_klass->desc->ops.count;
 156              _dich_chain_alloc(dc1, num_ops);
 157
 158              const op_type_funcs *sf = sc1->funcs;
 159              op_type_funcs *df = dc1->funcs;
 160              for (j = 0 ; j < num_ops ; j++, df++, sf++)
 161                {
 162                   if (sf->func)
 163                     {
 164                        memcpy(df, sf, sizeof(*df));
 165                     }
 166                }
 167           }
 168      }
 169 }
 170
 171 static inline const op_type_funcs *
 172 _dich_func_get(const Eo_Class *klass, Eo_Op op)
 173 {
 174    if (!klass->chain) return NULL;
 175
 176    size_t idx1 = DICH_CHAIN1(op) - 1;
 177    if (idx1 >= klass->class_id) return NULL;
 178    const Dich_Chain1 *chain1 = &klass->chain[idx1];
 179    if (!chain1->funcs) return NULL;
 180
 181    size_t idxl = DICH_CHAIN_LAST(op);
 182    /* num_ops is calculated from the class. */
 183    const Eo_Class *op_klass = ID_CLASS_GET(idx1 + 1);
 184    if (!op_klass || (idxl >= op_klass->desc->ops.count))
 185       return NULL;
 186
 187    return &chain1->funcs[idxl];
 188 }
 189
 190 static inline void
 191 _dich_func_set(Eo_Class *klass, Eo_Op op, eo_op_func_type func)
 192 {
 193    const Eo_Class *op_klass = OP_CLASS_GET(op);
 194    size_t num_ops;
 195
 196    /* Verify op is valid. */
 197    if (op_klass)
 198      {
 199         /* num_ops is calculated from the class. */
 200         num_ops = op_klass->desc->ops.count;
 201         if (DICH_CHAIN_LAST(op) >= num_ops)
 202           {
 203              ERR("OP %x is too big for the domain '%s', expected value < %x.",
 204                    op, op_klass->desc->name, op_klass->desc->ops.count);
 205              return;
 206           }
 207      }
 208    else
 209      {
 210         ERR("OP %x is from an illegal class.", op);
 211         return;
 212      }
 213
 214    if (!klass->chain)
 215      {
 216         klass->chain = calloc(klass->class_id, sizeof(*klass->chain));
 217      }
 218
 219    size_t idx1 = DICH_CHAIN1(op) - 1;
 220    Dich_Chain1 *chain1 = &klass->chain[idx1];
 221    _dich_chain_alloc(chain1, num_ops);
 222    chain1->funcs[DICH_CHAIN_LAST(op)].func = func;
 223    chain1->funcs[DICH_CHAIN_LAST(op)].src = klass;
 224 }
 225
 226 static inline void
 227 _dich_func_clean_all(Eo_Class *klass)
 228 {
 229    size_t i;
 230    Dich_Chain1 *chain1 = klass->chain;
 231
 232    if (!chain1)
 233       return;
 234
 235    for (i = 0 ; i < klass->class_id ; i++, chain1++)
 236      {
 237         if (chain1->funcs)
 238            free(chain1->funcs);
 239      }
 240    free(klass->chain);
 241    klass->chain = NULL;
 242 }
 243
 244 /* END OF DICH */
 245
 246 static const Eo_Op_Description noop_desc =
 247         EO_OP_DESCRIPTION(EO_NOOP, "", "No operation.");
 248
 249 static const Eo_Op_Description *
 250 _eo_op_id_desc_get(Eo_Op op)
 251 {
 252    const Eo_Class *klass = OP_CLASS_GET(op);
 253    Eo_Op sub_id = OP_SUB_ID_GET(op);
 254
 255    if (op == EO_NOOP)
 256       return &noop_desc;
 257
 258    if (klass && (sub_id < klass->desc->ops.count))
 259       return klass->desc->ops.descs + sub_id;
 260
 261    return NULL;
 262 }
 263
 264 static const char *
 265 _eo_op_id_name_get(Eo_Op op)
 266 {
 267    const Eo_Op_Description *desc = _eo_op_id_desc_get(op);
 268    return (desc) ? desc->name : NULL;
 269 }
 270
 271 static inline void
 272 _eo_kls_itr_init(const Eo_Class *obj_klass, Eo_Kls_Itr *cur, Eo_Op op, Eo_Kls_Itr *prev_state)
 273 {
 274    prev_state->op = cur->op;
 275    prev_state->kls_itr = cur->kls_itr;
 276
 277    /* If we are in a constructor/destructor or we changed an op - init. */
 278    if ((op == EO_NOOP) || (cur->op != op))
 279      {
 280         cur->op = op;
 281         cur->kls_itr = obj_klass->mro;
 282      }
 283 }
 284
 285 static inline void
 286 _eo_kls_itr_end(Eo_Kls_Itr *cur, Eo_Kls_Itr *prev_state)
 287 {
 288    if (cur->op != prev_state->op)
 289      {
 290         cur->op = prev_state->op;
 291         cur->kls_itr = prev_state->kls_itr;
 292      }
 293 }
 294
 295 static inline const Eo_Class *
 296 _eo_kls_itr_get(Eo_Kls_Itr *cur)
 297 {
 298    return (cur->kls_itr) ? *(cur->kls_itr) : NULL;
 299 }
 300
 301 static inline const Eo_Class *
 302 _eo_kls_itr_next(Eo_Kls_Itr *cur, Eo_Op op)
 303 {
 304    if (cur->op != op)
 305      {
 306         Eo_Op node_op = cur->op;
 307         ERR("Called with op %d ('%s') while expecting: %d ('%s'). This probaly means you called eo_*_super functions from a wrong place.",
 308               op, _eo_op_id_name_get(op),
 309               node_op, _eo_op_id_name_get(node_op));
 310         return NULL;
 311      }
 312
 313    const Eo_Class **kls_itr = cur->kls_itr;
 314    if (*kls_itr)
 315      {
 316         if (op != EO_NOOP)
 317           {
 318              const op_type_funcs *fsrc = _dich_func_get(*kls_itr, op);
 319
 320              while (*kls_itr && (*(kls_itr++) != fsrc->src))
 321                 ;
 322           }
 323         else
 324           {
 325              kls_itr++;
 326           }
 327
 328         cur->kls_itr = kls_itr;
 329         return *kls_itr;
 330      }
 331    else
 332      {
 333         return NULL;
 334      }
 335 }
 336
 337 static inline Eina_Bool
 338 _eo_kls_itr_reached_end(const Eo_Kls_Itr *cur)
 339 {
 340    const Eo_Class **kls_itr = cur->kls_itr;
 341    return !(*kls_itr && *(kls_itr + 1));
 342 }
 343
 344 static inline const op_type_funcs *
 345 _eo_kls_itr_func_get(const Eo_Class *klass, Eo_Kls_Itr *mro_itr, Eo_Op op, Eo_Kls_Itr *prev_state)
 346 {
 347    _eo_kls_itr_init(klass, mro_itr, op, prev_state);
 348    klass = _eo_kls_itr_get(mro_itr);
 349    if (klass)
 350      {
 351         const op_type_funcs *func = _dich_func_get(klass, op);
 352
 353         if (func && func->func)
 354           {
 355              return func;
 356           }
 357      }
 358
 359    return NULL;
 360 }
 361
 362 #define _EO_OP_ERR_NO_OP_PRINT(op, klass) \
 363    do \
 364       { \
 365          const Eo_Class *op_klass = OP_CLASS_GET(op); \
 366          const char *_dom_name = (op_klass) ? op_klass->desc->name : NULL; \
 367          ERR("Can't find func for op %x ('%s' of domain '%s') for class '%s'. Aborting.", \
 368                op, _eo_op_id_name_get(op), _dom_name, \
 369                (klass) ? klass->desc->name : NULL); \
 370       } \
 371    while (0)
 372
 373 static Eina_Bool
 374 _eo_op_internal(Eo *obj, Eo_Op_Type op_type, Eo_Op op, va_list *p_list)
 375 {
 376    Eina_Bool ret = EINA_FALSE;
 377
 378    const Eo_Op_Description *op_desc = _eo_op_id_desc_get(op);
 379
 380    if (op_desc)
 381      {
 382         if (op_desc->op_type == EO_OP_TYPE_CLASS)
 383           {
 384              ERR("Tried calling a class op '%s' (%d) from a non-class context.", (op_desc) ? op_desc->name : NULL, op);
 385              return EINA_FALSE;
 386           }
 387         else if ((op_type == EO_OP_TYPE_CONST) &&
 388               (op_desc->op_type != EO_OP_TYPE_CONST))
 389           {
 390              ERR("Tried calling non-const or non-existant op '%s' (%d) from a const (query) function.", (op_desc) ? op_desc->name : NULL, op);
 391              return EINA_FALSE;
 392           }
 393      }
 394
 395    Eo_Kls_Itr prev_state;
 396
 397      {
 398         const op_type_funcs *func =
 399            _eo_kls_itr_func_get(obj->klass, &obj->mro_itr, op, &prev_state);
 400         if (func)
 401           {
 402              func->func(obj, _eo_data_get(obj, func->src), p_list);
 403              ret = EINA_TRUE;
 404              goto end;
 405           }
 406      }
 407
 408    /* Try composite objects */
 409      {
 410         Eina_List *itr;
 411         Eo *emb_obj;
 412         EINA_LIST_FOREACH(obj->composite_objects, itr, emb_obj)
 413           {
 414              if (_eo_op_internal(emb_obj, op_type, op, p_list))
 415                {
 416                   ret = EINA_TRUE;
 417                   goto end;
 418                }
 419           }
 420      }
 421
 422 end:
 423    _eo_kls_itr_end(&obj->mro_itr, &prev_state);
 424    return ret;
 425 }
 426
 427 EAPI Eina_Bool
 428 eo_do_internal(Eo *obj, Eo_Op_Type op_type, ...)
 429 {
 430    Eina_Bool ret = EINA_TRUE;
 431    Eo_Op op = EO_NOOP;
 432    va_list p_list;
 433
 434    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE);
 435
 436    _eo_ref(obj);
 437
 438    va_start(p_list, op_type);
 439
 440    op = va_arg(p_list, Eo_Op);
 441    while (op)
 442      {
 443         if (!_eo_op_internal(obj, op_type, op, &p_list))
 444           {
 445              _EO_OP_ERR_NO_OP_PRINT(op, obj->klass);
 446              ret = EINA_FALSE;
 447              break;
 448           }
 449         op = va_arg(p_list, Eo_Op);
 450      }
 451
 452    va_end(p_list);
 453
 454    _eo_unref(obj);
 455    return ret;
 456 }
 457
 458 EAPI Eina_Bool
 459 eo_do_super_internal(Eo *obj, Eo_Op_Type op_type, Eo_Op op, ...)
 460 {
 461    const Eo_Class *nklass;
 462    Eina_Bool ret = EINA_TRUE;
 463    va_list p_list;
 464    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE);
 465
 466    /* Advance the kls itr. */
 467    nklass = _eo_kls_itr_next(&obj->mro_itr, op);
 468
 469    if (obj->mro_itr.op != op)
 470       return EINA_FALSE;
 471
 472    va_start(p_list, op);
 473    if (!_eo_op_internal(obj, op_type, op, &p_list))
 474      {
 475         _EO_OP_ERR_NO_OP_PRINT(op, nklass);
 476         ret = EINA_FALSE;
 477      }
 478    va_end(p_list);
 479
 480    return ret;
 481 }
 482
 483 static Eina_Bool
 484 _eo_class_op_internal(Eo_Class *klass, Eo_Op op, va_list *p_list)
 485 {
 486    Eina_Bool ret = EINA_FALSE;
 487
 488    const Eo_Op_Description *op_desc = _eo_op_id_desc_get(op);
 489
 490    if (op_desc)
 491      {
 492         if (op_desc->op_type != EO_OP_TYPE_CLASS)
 493           {
 494              ERR("Tried calling an instant op '%s' (%d) from a class context.", (op_desc) ? op_desc->name : NULL, op);
 495              return EINA_FALSE;
 496           }
 497      }
 498
 499    Eo_Kls_Itr prev_state;
 500
 501      {
 502         const op_type_funcs *func =
 503            _eo_kls_itr_func_get(klass, &klass->mro_itr, op, &prev_state);
 504         if (func)
 505           {
 506              ((eo_op_func_type_class) func->func)(klass, p_list);
 507              ret = EINA_TRUE;
 508              goto end;
 509           }
 510      }
 511
 512 end:
 513    _eo_kls_itr_end(&klass->mro_itr, &prev_state);
 514    return ret;
 515 }
 516
 517 EAPI Eina_Bool
 518 eo_class_do_internal(const Eo_Class *klass, ...)
 519 {
 520    Eina_Bool ret = EINA_TRUE;
 521    Eo_Op op = EO_NOOP;
 522    va_list p_list;
 523
 524    EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, EINA_FALSE);
 525
 526    va_start(p_list, klass);
 527
 528    op = va_arg(p_list, Eo_Op);
 529    while (op)
 530      {
 531         if (!_eo_class_op_internal((Eo_Class *) klass, op, &p_list))
 532           {
 533              _EO_OP_ERR_NO_OP_PRINT(op, klass);
 534              ret = EINA_FALSE;
 535              break;
 536           }
 537         op = va_arg(p_list, Eo_Op);
 538      }
 539
 540    va_end(p_list);
 541
 542    return ret;
 543 }
 544
 545 EAPI Eina_Bool
 546 eo_class_do_super_internal(const Eo_Class *klass, Eo_Op op, ...)
 547 {
 548    const Eo_Class *nklass;
 549    Eina_Bool ret = EINA_TRUE;
 550    va_list p_list;
 551    EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, EINA_FALSE);
 552
 553    /* Advance the kls itr. */
 554    nklass = _eo_kls_itr_next(&((Eo_Class *) klass)->mro_itr, op);
 555
 556    if (klass->mro_itr.op != op)
 557       return EINA_FALSE;
 558
 559    va_start(p_list, op);
 560    if (!_eo_class_op_internal((Eo_Class *) klass, op, &p_list))
 561      {
 562         _EO_OP_ERR_NO_OP_PRINT(op, nklass);
 563         ret = EINA_FALSE;
 564      }
 565    va_end(p_list);
 566
 567    return ret;
 568 }
 569
 570 EAPI const Eo_Class *
 571 eo_class_get(const Eo *obj)
 572 {
 573    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE);
 574
 575    return obj->klass;
 576 }
 577
 578 EAPI const char *
 579 eo_class_name_get(const Eo_Class *klass)
 580 {
 581    EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, NULL);
 582
 583    return klass->desc->name;
 584 }
 585
 586 static void
 587 _eo_class_base_op_init(Eo_Class *klass)
 588 {
 589    const Eo_Class_Description *desc = klass->desc;
 590    if (!desc || !desc->ops.base_op_id)
 591       return;
 592
 593    /* FIXME: Depends on values defined above! */
 594    *(desc->ops.base_op_id) = klass->class_id << OP_CLASS_OFFSET;
 595 }
 596
 597 #ifndef NDEBUG
 598 static Eina_Bool
 599 _eo_class_mro_has(const Eo_Class *klass, const Eo_Class *find)
 600 {
 601    const Eo_Class **itr;
 602    for (itr = klass->mro ; *itr ; itr++)
 603      {
 604         if (*itr == find)
 605           {
 606              return EINA_TRUE;
 607           }
 608      }
 609
 610    return EINA_FALSE;
 611 }
 612 #endif
 613
 614 static Eina_List *
 615 _eo_class_mro_add(Eina_List *mro, const Eo_Class *klass)
 616 {
 617    Eina_List *extn_pos = NULL;
 618    Eina_Bool check_consistency = !mro;
 619    if (!klass)
 620       return mro;
 621
 622    mro = eina_list_append(mro, klass);
 623
 624    /* Recursively add extenions. */
 625      {
 626         Eo_Extension_Node *extn;
 627         EINA_INLIST_FOREACH(klass->extensions, extn)
 628           {
 629              mro = _eo_class_mro_add(mro, extn->klass);
 630              /* Not possible: if (!mro) return NULL; */
 631
 632              if (check_consistency)
 633                {
 634                   extn_pos = eina_list_append(extn_pos, eina_list_last(mro));
 635                }
 636           }
 637      }
 638
 639    /* Check if we can create a consistent mro. We only do it for the class
 640     * we are working on (i.e no parents). */
 641    if (check_consistency)
 642      {
 643         Eo_Extension_Node *extn;
 644
 645         Eina_List *itr = extn_pos;
 646         EINA_INLIST_FOREACH(klass->extensions, extn)
 647           {
 648              /* Get the first one after the extension. */
 649              Eina_List *extn_list = eina_list_next(eina_list_data_get(itr));
 650
 651              /* If we found the extension again. */
 652              if (eina_list_data_find_list(extn_list, extn->klass))
 653                {
 654                   eina_list_free(mro);
 655                   ERR("Cannot create a consistent method resolution order for class '%s' because of '%s'.", klass->desc->name, extn->klass->desc->name);
 656                   return NULL;
 657                }
 658
 659              itr = eina_list_next(itr);
 660           }
 661      }
 662
 663
 664    mro = _eo_class_mro_add(mro, klass->parent);
 665
 666    return mro;
 667 }
 668
 669 static Eina_Bool
 670 _eo_class_mro_init(Eo_Class *klass)
 671 {
 672    Eina_List *mro = NULL;
 673
 674    DBG("Started creating MRO for class '%s'", klass->desc->name);
 675    mro = _eo_class_mro_add(mro, klass);
 676
 677    if (!mro)
 678       return EINA_FALSE;
 679
 680    /* Remove duplicates and make them the right order. */
 681      {
 682         Eina_List *itr1, *itr2, *itr2n;
 683
 684         itr1 = eina_list_last(mro);
 685         while (itr1)
 686           {
 687              itr2 = eina_list_prev(itr1);
 688
 689              while (itr2)
 690                {
 691                   itr2n = eina_list_prev(itr2);
 692
 693                   if (eina_list_data_get(itr1) == eina_list_data_get(itr2))
 694                     {
 695                        mro = eina_list_remove_list(mro, itr2);
 696                     }
 697
 698                   itr2 = itr2n;
 699                }
 700
 701              itr1 = eina_list_prev(itr1);
 702           }
 703      }
 704
 705    /* Copy the mro and free the list. */
 706      {
 707         const Eo_Class *kls_itr;
 708         const Eo_Class **mro_itr;
 709         klass->mro = calloc(sizeof(*klass->mro), eina_list_count(mro) + 1);
 710
 711         mro_itr = klass->mro;
 712
 713         EINA_LIST_FREE(mro, kls_itr)
 714           {
 715              *(mro_itr++) = kls_itr;
 716
 717              DBG("Added '%s' to MRO", kls_itr->desc->name);
 718           }
 719         *(mro_itr) = NULL;
 720      }
 721
 722    DBG("Finished creating MRO for class '%s'", klass->desc->name);
 723
 724    return EINA_TRUE;
 725 }
 726
 727 static void
 728 _eo_class_constructor(Eo_Class *klass)
 729 {
 730    if (klass->constructed)
 731       return;
 732
 733    klass->constructed = EINA_TRUE;
 734
 735    if (klass->desc->class_constructor)
 736       klass->desc->class_constructor(klass);
 737 }
 738
 739 EAPI void
 740 eo_class_funcs_set(Eo_Class *klass, const Eo_Op_Func_Description *func_descs)
 741 {
 742    EO_MAGIC_RETURN(klass, EO_CLASS_EINA_MAGIC);
 743
 744    const Eo_Op_Func_Description *itr;
 745    itr = func_descs;
 746    if (itr)
 747      {
 748         for ( ; itr->op != 0 ; itr++)
 749           {
 750              const Eo_Op_Description *op_desc = _eo_op_id_desc_get(itr->op);
 751
 752              if (EINA_LIKELY(!op_desc || (itr->op_type == op_desc->op_type)))
 753                {
 754                   _dich_func_set(klass, itr->op, itr->func);
 755                }
 756              else
 757                {
 758                   ERR("Set function's op type (%d) is different than the one in the op description (%d) for op '%s' in class '%s'.", itr->op_type, op_desc->op_type, op_desc->name, klass->desc->name);
 759                }
 760           }
 761      }
 762 }
 763
 764 static void
 765 eo_class_free(Eo_Class *klass)
 766 {
 767    if (klass->constructed)
 768      {
 769         if (klass->desc->class_destructor)
 770            klass->desc->class_destructor(klass);
 771
 772         _dich_func_clean_all(klass);
 773      }
 774
 775      {
 776         Eina_Inlist *itrn;
 777         Eo_Extension_Node *extn = NULL;
 778         EINA_INLIST_FOREACH_SAFE(klass->extensions, itrn, extn)
 779           {
 780              free(extn);
 781           }
 782      }
 783
 784    if (klass->mro)
 785       free(klass->mro);
 786
 787    if (klass->extn_data_off)
 788       free(klass->extn_data_off);
 789
 790    free(klass);
 791 }
 792
 793 /* DEVCHECK */
 794 static Eina_Bool
 795 _eo_class_check_op_descs(const Eo_Class *klass)
 796 {
 797    const Eo_Class_Description *desc = klass->desc;
 798    const Eo_Op_Description *itr;
 799    size_t i;
 800
 801    if (desc->ops.count > 0)
 802      {
 803         if (!desc->ops.base_op_id)
 804           {
 805              ERR("Class '%s' has a non-zero ops count, but base_id is NULL.",
 806                    desc->name);
 807              return EINA_FALSE;
 808           }
 809
 810         if (!desc->ops.descs)
 811           {
 812              ERR("Class '%s' has a non-zero ops count, but there are no descs.",
 813                    desc->name);
 814              return EINA_FALSE;
 815           }
 816      }
 817
 818    itr = desc->ops.descs;
 819    for (i = 0 ; i < desc->ops.count ; i++, itr++)
 820      {
 821         if (itr->sub_op != i)
 822           {
 823              if (itr->name)
 824                {
 825                   ERR("Wrong order in Ops description for class '%s'. Expected %d and got %d", desc->name, i, itr->sub_op);
 826                }
 827              else
 828                {
 829                   ERR("Found too few Ops description for class '%s'. Expected %d descriptions, but found %d.", desc->name, desc->ops.count, i);
 830                }
 831              return EINA_FALSE;
 832           }
 833      }
 834
 835    if (itr && itr->name)
 836      {
 837         ERR("Found extra Ops description for class '%s'. Expected %d descriptions, but found more.", desc->name, desc->ops.count);
 838         return EINA_FALSE;
 839      }
 840
 841    return EINA_TRUE;
 842 }
 843
 844 EAPI const Eo_Class *
 845 eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent, ...)
 846 {
 847    Eo_Class *klass;
 848    va_list p_list;
 849
 850    if (parent && !EINA_MAGIC_CHECK(parent, EO_CLASS_EINA_MAGIC))
 851      {
 852         EINA_MAGIC_FAIL(parent, EO_CLASS_EINA_MAGIC);
 853         return NULL;
 854      }
 855
 856    va_start(p_list, parent);
 857
 858    EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
 859    EINA_SAFETY_ON_NULL_RETURN_VAL(desc->name, NULL);
 860
 861    /* Check restrictions on Interface types. */
 862    if (desc->type == EO_CLASS_TYPE_INTERFACE)
 863      {
 864         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->constructor, NULL);
 865         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->destructor, NULL);
 866         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->class_constructor, NULL);
 867         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->class_destructor, NULL);
 868         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->data_size, NULL);
 869      }
 870
 871    klass = calloc(1, sizeof(Eo_Class));
 872    klass->parent = parent;
 873
 874    /* Handle class extensions */
 875      {
 876         Eo_Class *extn = NULL;
 877
 878         extn = va_arg(p_list, Eo_Class *);
 879         while (extn)
 880           {
 881              switch (extn->desc->type)
 882                {
 883                 case EO_CLASS_TYPE_REGULAR:
 884                 case EO_CLASS_TYPE_REGULAR_NO_INSTANT:
 885                    /* Use it like an interface. */
 886                 case EO_CLASS_TYPE_INTERFACE:
 887                    break;
 888                 case EO_CLASS_TYPE_MIXIN:
 889                      {
 890                         Eo_Extension_Node *node = calloc(1, sizeof(*node));
 891                         node->klass = extn;
 892                         klass->extensions =
 893                            eina_inlist_append(klass->extensions,
 894                                  EINA_INLIST_GET(node));
 895                      }
 896                    break;
 897                }
 898
 899              extn = va_arg(p_list, Eo_Class *);
 900           }
 901      }
 902
 903    klass->desc = desc;
 904
 905    /* Handle the inheritance */
 906    if (klass->parent)
 907      {
 908         /* Verify the inheritance is allowed. */
 909         switch (klass->desc->type)
 910           {
 911            case EO_CLASS_TYPE_REGULAR:
 912            case EO_CLASS_TYPE_REGULAR_NO_INSTANT:
 913               if ((klass->parent->desc->type != EO_CLASS_TYPE_REGULAR) &&
 914                     (klass->parent->desc->type != EO_CLASS_TYPE_REGULAR_NO_INSTANT))
 915                 {
 916                    ERR("Regular classes ('%s') aren't allowed to inherit from non-regular classes ('%s').", klass->desc->name, klass->parent->desc->name);
 917                    goto cleanup;
 918                 }
 919               break;
 920            case EO_CLASS_TYPE_INTERFACE:
 921            case EO_CLASS_TYPE_MIXIN:
 922               if ((klass->parent->desc->type != EO_CLASS_TYPE_INTERFACE) &&
 923                     (klass->parent->desc->type != EO_CLASS_TYPE_MIXIN))
 924                 {
 925                    ERR("Non-regular classes ('%s') aren't allowed to inherit from regular classes ('%s').", klass->desc->name, klass->parent->desc->name);
 926                    goto cleanup;
 927                 }
 928               break;
 929           }
 930
 931
 932         /* Update the current offset. */
 933         /* FIXME: Make sure this alignment is enough. */
 934         klass->data_offset = klass->parent->data_offset +
 935            EO_ALIGN_SIZE(klass->parent->desc->data_size);
 936      }
 937
 938    if (!_eo_class_check_op_descs(klass))
 939      {
 940         goto cleanup;
 941      }
 942
 943    if (!_eo_class_mro_init(klass))
 944      {
 945         goto cleanup;
 946      }
 947
 948    /* create MIXIN offset table. */
 949      {
 950         const Eo_Class **mro_itr = klass->mro;
 951         Eo_Extension_Data_Offset *extn_data_itr;
 952         size_t extn_num = 0;
 953         size_t extn_data_off = klass->data_offset +
 954            EO_ALIGN_SIZE(klass->desc->data_size);
 955
 956         /* FIXME: Make faster... */
 957         while (*mro_itr)
 958           {
 959              if (((*mro_itr)->desc->type == EO_CLASS_TYPE_MIXIN) &&
 960                    ((*mro_itr)->desc->data_size > 0))
 961                {
 962                   extn_num++;
 963                }
 964              mro_itr++;
 965           }
 966
 967         klass->extn_data_off = calloc(extn_num + 1,
 968               sizeof(*klass->extn_data_off));
 969
 970         extn_data_itr = klass->extn_data_off;
 971         mro_itr = klass->mro;
 972         while (*mro_itr)
 973           {
 974              if (((*mro_itr)->desc->type == EO_CLASS_TYPE_MIXIN) &&
 975                    ((*mro_itr)->desc->data_size > 0))
 976                {
 977                   extn_data_itr->klass = *mro_itr;
 978                   extn_data_itr->offset = extn_data_off;
 979
 980                   extn_data_off += EO_ALIGN_SIZE(extn_data_itr->klass->desc->data_size);
 981                   extn_data_itr++;
 982                }
 983              mro_itr++;
 984           }
 985
 986         klass->extn_data_size = extn_data_off;
 987      }
 988
 989    eina_lock_take(&_eo_class_creation_lock);
 990    klass->class_id = ++_eo_classes_last_id;
 991      {
 992         /* FIXME: Handle errors. */
 993         Eo_Class **tmp;
 994         tmp = realloc(_eo_classes, _eo_classes_last_id * sizeof(*_eo_classes));
 995         _eo_classes = tmp;
 996         _eo_classes[klass->class_id - 1] = klass;
 997      }
 998    eina_lock_release(&_eo_class_creation_lock);
 999
1000    EINA_MAGIC_SET(klass, EO_CLASS_EINA_MAGIC);
1001
1002    /* Flatten the function array */
1003      {
1004         const Eo_Class **mro_itr = klass->mro;
1005         for (  ; *mro_itr ; mro_itr++)
1006            ;
1007
1008         for ( mro_itr-- ; mro_itr >= klass->mro ; mro_itr--)
1009           {
1010              _dich_copy_all(klass, *mro_itr);
1011           }
1012      }
1013
1014    _eo_class_base_op_init(klass);
1015
1016    _eo_class_constructor(klass);
1017
1018    va_end(p_list);
1019
1020    return klass;
1021
1022 cleanup:
1023    eo_class_free(klass);
1024    return NULL;
1025 }
1026
1027 EAPI Eo *
1028 eo_add(const Eo_Class *klass, Eo *parent)
1029 {
1030    EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, NULL);
1031
1032    if (parent) EO_MAGIC_RETURN_VAL(parent, EO_EINA_MAGIC, NULL);
1033
1034    if (EINA_UNLIKELY(klass->desc->type != EO_CLASS_TYPE_REGULAR))
1035      {
1036         ERR("Class '%s' is not instantiate-able. Aborting.", klass->desc->name);
1037         return NULL;
1038      }
1039
1040    Eo *obj = calloc(1, EO_ALIGN_SIZE(sizeof(*obj)) +
1041          (klass->data_offset + EO_ALIGN_SIZE(klass->desc->data_size)) +
1042          klass->extn_data_size);
1043    obj->klass = klass;
1044    obj->parent = parent;
1045
1046    obj->refcount++;
1047
1048    Eo_Kls_Itr prev_state;
1049
1050    _eo_kls_itr_init(klass, &obj->mro_itr, EO_NOOP, &prev_state);
1051    _eo_error_unset(obj);
1052
1053    EINA_MAGIC_SET(obj, EO_EINA_MAGIC);
1054    _eo_ref(obj);
1055    _eo_constructor(obj, klass);
1056
1057    if (EINA_UNLIKELY(_eo_error_get(obj)))
1058      {
1059         ERR("Type '%s' - One of the object constructors have failed.", klass->desc->name);
1060         goto fail;
1061      }
1062
1063    if (EINA_UNLIKELY(!_eo_kls_itr_reached_end(&obj->mro_itr)))
1064      {
1065         ERR("Type '%s' - Not all of the object constructors have been executed.", klass->desc->name);
1066         goto fail;
1067      }
1068    _eo_kls_itr_end(&obj->mro_itr, &prev_state);
1069    _eo_unref(obj);
1070
1071    return obj;
1072
1073 fail:
1074    _eo_kls_itr_end(&obj->mro_itr, &prev_state);
1075    /* Unref twice, once for the ref above, and once for the basic object ref. */
1076    _eo_unref(obj);
1077    _eo_unref(obj);
1078    return NULL;
1079 }
1080
1081 typedef struct
1082 {
1083    EINA_INLIST;
1084    const Eo *ref_obj;
1085    const char *file;
1086    int line;
1087 } Eo_Xref_Node;
1088
1089 EAPI Eo *
1090 eo_xref_internal(Eo *obj, const Eo *ref_obj, const char *file, int line)
1091 {
1092    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, obj);
1093
1094    _eo_ref(obj);
1095
1096 #ifndef NDEBUG
1097    Eo_Xref_Node *xref = calloc(1, sizeof(*xref));
1098    xref->ref_obj = ref_obj;
1099    xref->file = file;
1100    xref->line = line;
1101
1102    /* FIXME: Make it sorted. */
1103    obj->xrefs = eina_inlist_prepend(obj->xrefs, EINA_INLIST_GET(xref));
1104 #else
1105    (void) ref_obj;
1106    (void) file;
1107    (void) line;
1108 #endif
1109
1110    return obj;
1111 }
1112
1113 EAPI void
1114 eo_xunref(Eo *obj, const Eo *ref_obj)
1115 {
1116    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1117 #ifndef NDEBUG
1118    Eo_Xref_Node *xref = NULL;
1119    EINA_INLIST_FOREACH(obj->xrefs, xref)
1120      {
1121         if (xref->ref_obj == ref_obj)
1122            break;
1123      }
1124
1125    if (xref)
1126      {
1127         obj->xrefs = eina_inlist_remove(obj->xrefs, EINA_INLIST_GET(xref));
1128         free(xref);
1129      }
1130    else
1131      {
1132         ERR("ref_obj (%p) does not reference obj (%p). Aborting unref.", ref_obj, obj);
1133         return;
1134      }
1135 #else
1136    (void) ref_obj;
1137 #endif
1138    _eo_unref(obj);
1139 }
1140
1141 static inline Eo *
1142 _eo_ref(Eo *obj)
1143 {
1144    obj->refcount++;
1145    return obj;
1146 }
1147
1148 EAPI Eo *
1149 eo_ref(const Eo *_obj)
1150 {
1151    Eo *obj = (Eo *) _obj;
1152    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, obj);
1153
1154    return _eo_ref(obj);
1155 }
1156
1157 static void
1158 _eo_del_internal(Eo *obj)
1159 {
1160    if (obj->del)
1161       return;
1162    /* We need that for the event callbacks that may ref/unref. */
1163    obj->refcount++;
1164
1165    eo_do(obj, eo_event_callback_call(EO_EV_DEL, NULL, NULL));
1166    obj->del = EINA_TRUE;
1167
1168    const Eo_Class *klass = eo_class_get(obj);
1169    Eo_Kls_Itr prev_state;
1170
1171    _eo_kls_itr_init(klass, &obj->mro_itr, EO_NOOP, &prev_state);
1172    _eo_error_unset(obj);
1173    _eo_destructor(obj, klass);
1174    if (_eo_error_get(obj))
1175      {
1176         ERR("Type '%s' - One of the object destructors have failed.", klass->desc->name);
1177      }
1178
1179    if (!_eo_kls_itr_reached_end(&obj->mro_itr))
1180      {
1181         ERR("Type '%s' - Not all of the object destructors have been executed.", klass->desc->name);
1182      }
1183    _eo_kls_itr_end(&obj->mro_itr, &prev_state);
1184    /*FIXME: add eo_class_unref(klass) ? - just to clear the caches. */
1185
1186    Eina_List *itr, *itr_n;
1187    Eo *emb_obj;
1188    EINA_LIST_FOREACH_SAFE(obj->composite_objects, itr, itr_n, emb_obj)
1189      {
1190         eo_composite_object_detach(obj, emb_obj);
1191      }
1192
1193    obj->refcount--;
1194 }
1195
1196 static inline void
1197 _eo_unref(Eo *obj)
1198 {
1199    if (--(obj->refcount) == 0)
1200      {
1201         _eo_del_internal(obj);
1202
1203 #ifndef NDEBUG
1204    /* If for some reason it's not empty, clear it. */
1205    while (obj->xrefs)
1206      {
1207         WRN("obj->xrefs is not empty, possibly a bug, please report. - An error will be reported for each xref in the stack.");
1208         Eina_Inlist *nitr = obj->xrefs->next;
1209         free(EINA_INLIST_CONTAINER_GET(obj->xrefs, Eo_Xref_Node));
1210         obj->xrefs = nitr;
1211      }
1212 #endif
1213
1214         EINA_MAGIC_SET(obj, EO_DELETED_EINA_MAGIC);
1215         free(obj);
1216      }
1217 }
1218
1219 EAPI void
1220 eo_unref(const Eo *_obj)
1221 {
1222    Eo *obj = (Eo *) _obj;
1223    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1224
1225    _eo_unref(obj);
1226 }
1227
1228 EAPI int
1229 eo_ref_get(const Eo *obj)
1230 {
1231    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, 0);
1232
1233    return obj->refcount;
1234 }
1235
1236 EAPI void
1237 eo_del(Eo *obj)
1238 {
1239    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1240
1241    _eo_del_internal(obj);
1242    _eo_unref(obj);
1243 }
1244
1245 EAPI Eo *
1246 eo_parent_get(const Eo *obj)
1247 {
1248    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, NULL);
1249
1250    return obj->parent;
1251 }
1252
1253 EAPI void
1254 eo_error_set_internal(const Eo *obj, const char *file, int line)
1255 {
1256    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1257
1258    ERR("Error with obj '%p' at %s:%d", obj, file, line);
1259
1260    ((Eo *) obj)->construct_error = EINA_TRUE;
1261 }
1262
1263 static inline void
1264 _eo_error_unset(Eo *obj)
1265 {
1266    obj->construct_error = EINA_FALSE;
1267 }
1268
1269 /**
1270  * @internal
1271  * @brief Check if there was an error when constructing, destructing or calling a function of the object.
1272  * @param obj the object to work on.
1273  * @return @c EINA_TRUE if there was an error.
1274  */
1275 static inline Eina_Bool
1276 _eo_error_get(const Eo *obj)
1277 {
1278    return obj->construct_error;
1279 }
1280
1281 static inline void
1282 _eo_constructor_default(Eo *obj)
1283 {
1284    eo_constructor_super(obj);
1285 }
1286
1287 static inline void
1288 _eo_destructor_default(Eo *obj)
1289 {
1290    eo_destructor_super(obj);
1291 }
1292
1293 static void
1294 _eo_constructor(Eo *obj, const Eo_Class *klass)
1295 {
1296    if (!klass)
1297       return;
1298
1299    if (klass->desc->constructor)
1300       klass->desc->constructor(obj, _eo_data_get(obj, klass));
1301    else
1302       _eo_constructor_default(obj);
1303 }
1304
1305 static void
1306 _eo_destructor(Eo *obj, const Eo_Class *klass)
1307 {
1308    if (!klass)
1309       return;
1310
1311    if (klass->desc->destructor)
1312       klass->desc->destructor(obj, _eo_data_get(obj, klass));
1313    else
1314       _eo_destructor_default(obj);
1315 }
1316
1317 EAPI void
1318 eo_constructor_super(Eo *obj)
1319 {
1320    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1321
1322    _eo_constructor(obj, _eo_kls_itr_next(&obj->mro_itr, EO_NOOP));
1323 }
1324
1325 EAPI void
1326 eo_destructor_super(Eo *obj)
1327 {
1328    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1329
1330    _eo_destructor(obj, _eo_kls_itr_next(&obj->mro_itr, EO_NOOP));
1331 }
1332
1333 static inline void *
1334 _eo_data_get(const Eo *obj, const Eo_Class *klass)
1335 {
1336    if (EINA_LIKELY(klass->desc->data_size > 0))
1337      {
1338         if (EINA_UNLIKELY(klass->desc->type == EO_CLASS_TYPE_MIXIN))
1339           {
1340              Eo_Extension_Data_Offset *doff_itr =
1341                 eo_class_get(obj)->extn_data_off;
1342
1343              if (!doff_itr)
1344                 return NULL;
1345
1346              while (doff_itr->klass)
1347                {
1348                   if (doff_itr->klass == klass)
1349                      return ((char *) obj) + EO_ALIGN_SIZE(sizeof(*obj)) +
1350                            doff_itr->offset;
1351                   doff_itr++;
1352                }
1353           }
1354         else
1355           {
1356           return ((char *) obj) + EO_ALIGN_SIZE(sizeof(*obj)) +
1357              klass->data_offset;
1358           }
1359      }
1360
1361    return NULL;
1362 }
1363
1364 EAPI void *
1365 eo_data_get(const Eo *obj, const Eo_Class *klass)
1366 {
1367    void *ret;
1368    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, NULL);
1369
1370 #ifndef NDEBUG
1371    if (!_eo_class_mro_has(obj->klass, klass))
1372      {
1373         ERR("Tried getting data of class '%s' from object of class '%s', but the former is not a direct inheritance of the latter.", klass->desc->name, obj->klass->desc->name);
1374         return NULL;
1375      }
1376 #endif
1377
1378    ret = _eo_data_get(obj, klass);
1379
1380    if (!ret && (klass->desc->data_size == 0))
1381      {
1382         ERR("Tried getting data of class '%s', but it has none..", klass->desc->name);
1383      }
1384
1385    return ret;
1386 }
1387
1388 EAPI Eina_Bool
1389 eo_init(void)
1390 {
1391    const char *log_dom = "eo";
1392    if (_eo_init_count++ > 0)
1393       return EINA_TRUE;
1394
1395    eina_init();
1396
1397    _eo_classes = NULL;
1398    _eo_classes_last_id = 0;
1399    _eo_log_dom = eina_log_domain_register(log_dom, EINA_COLOR_LIGHTBLUE);
1400    if (_eo_log_dom < 0)
1401      {
1402         EINA_LOG_ERR("Could not register log domain: %s", log_dom);
1403         return EINA_FALSE;
1404      }
1405
1406    if (!eina_lock_new(&_eo_class_creation_lock))
1407      {
1408         EINA_LOG_ERR("Could not init lock.");
1409         return EINA_FALSE;
1410      }
1411
1412    eina_magic_string_static_set(EO_EINA_MAGIC, EO_EINA_MAGIC_STR);
1413    eina_magic_string_static_set(EO_DELETED_EINA_MAGIC,
1414          EO_DELETED_EINA_MAGIC_STR);
1415    eina_magic_string_static_set(EO_CLASS_EINA_MAGIC,
1416          EO_CLASS_EINA_MAGIC_STR);
1417
1418    return EINA_TRUE;
1419 }
1420
1421 EAPI Eina_Bool
1422 eo_shutdown(void)
1423 {
1424    size_t i;
1425    Eo_Class **cls_itr = _eo_classes;
1426
1427    if (--_eo_init_count > 0)
1428       return EINA_TRUE;
1429
1430    for (i = 0 ; i < _eo_classes_last_id ; i++, cls_itr++)
1431      {
1432         if (*cls_itr)
1433            eo_class_free(*cls_itr);
1434      }
1435
1436    if (_eo_classes)
1437       free(_eo_classes);
1438
1439    eina_lock_free(&_eo_class_creation_lock);
1440
1441    eina_log_domain_unregister(_eo_log_dom);
1442    _eo_log_dom = -1;
1443
1444    eina_shutdown();
1445    return EINA_TRUE;
1446 }
1447
1448 EAPI void
1449 eo_composite_object_attach(Eo *obj, Eo *emb_obj)
1450 {
1451    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1452    EO_MAGIC_RETURN(emb_obj, EO_EINA_MAGIC);
1453
1454    eo_xref(emb_obj, obj);
1455    obj->composite_objects = eina_list_prepend(obj->composite_objects, emb_obj);
1456 }
1457
1458 EAPI void
1459 eo_composite_object_detach(Eo *obj, Eo *emb_obj)
1460 {
1461    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1462    EO_MAGIC_RETURN(emb_obj, EO_EINA_MAGIC);
1463
1464    obj->composite_objects = eina_list_remove(obj->composite_objects, emb_obj);
1465    eo_xunref(emb_obj, obj);
1466 }
1467
1468 EAPI Eina_Bool
1469 eo_composite_is(Eo *emb_obj)
1470 {
1471    if (!EINA_MAGIC_CHECK(emb_obj, EO_EINA_MAGIC))
1472      {
1473         EINA_MAGIC_FAIL(emb_obj, EO_EINA_MAGIC);
1474         return EINA_FALSE;
1475      }
1476
1477    Eo *obj = eo_parent_get(emb_obj);
1478    Eina_List *itr;
1479    Eo *tmp;
1480
1481    if (!obj)
1482       return EINA_FALSE;
1483
1484    EINA_LIST_FOREACH(obj->composite_objects, itr, tmp)
1485      {
1486         if (tmp == emb_obj)
1487            return EINA_TRUE;
1488      }
1489
1490    return EINA_FALSE;
1491 }
1492
1493