X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=lib%2Feo.c;h=823f3445ece98160e18fbe477f7ab816a35508a7;hb=2e0bf3b0f6debd8268711aea0d380ee07cf6a316;hp=48f5858fdabd22b30c626ae554ab6a6598f59f5d;hpb=2f09fd71338655ae72506fc9692b263ce2f3a985;p=profile%2Fivi%2Feobj.git diff --git a/lib/eo.c b/lib/eo.c index 48f5858..823f344 100644 --- a/lib/eo.c +++ b/lib/eo.c @@ -5,7 +5,8 @@ #include "config.h" -typedef size_t Eo_Class_Id; +/* The last id that should be reserved for statically allocated classes. */ +#define EO_STATIC_IDS_LAST 10 /* Used inside the class_get functions of classes, see #EO_DEFINE_CLASS */ EAPI Eina_Lock _eo_class_creation_lock; @@ -31,7 +32,9 @@ typedef struct struct _Eo { EINA_MAGIC + EINA_INLIST; Eo *parent; + Eina_Inlist *children; const Eo_Class *klass; int refcount; #ifndef NDEBUG @@ -42,8 +45,10 @@ struct _Eo { Eo_Kls_Itr mro_itr; + Eina_Bool composite:1; Eina_Bool del:1; Eina_Bool construct_error:1; + Eina_Bool manual_free:1; }; /* Start of Dich */ @@ -54,8 +59,7 @@ struct _Eo { #define DICH_CHAIN1(x) (((x) >> 16) & DICH_CHAIN1_MASK) #define DICH_CHAIN_LAST(x) ((x) & DICH_CHAIN_LAST_MASK) -#define OP_CLASS_OFFSET 16 -#define OP_CLASS_OFFSET_GET(x) (((x) >> OP_CLASS_OFFSET) & 0xffff) +#define OP_CLASS_OFFSET_GET(x) (((x) >> EO_OP_CLASS_OFFSET) & 0xffff) #define OP_CLASS_GET(op) ({ \ Eo_Class_Id tmp = OP_CLASS_OFFSET_GET(op); \ ID_CLASS_GET(tmp); \ @@ -113,6 +117,7 @@ struct _Eo_Class size_t extn_data_size; const Eo_Class **mro; + Eo_Kls_Itr mro_itr; size_t data_offset; /* < Offset of the data within object data. */ @@ -303,7 +308,7 @@ _eo_kls_itr_next(Eo_Kls_Itr *cur, Eo_Op op) if (cur->op != op) { Eo_Op node_op = cur->op; - ERR("Called with op %d ('%s') while expecting: %d ('%s'). This probaly means you called eo_*_super functions from a wrong place.", + ERR("Called with op %x ('%s') while expecting: %x ('%s'). This probaly means you called eo_*_super functions from a wrong place.", op, _eo_op_id_name_get(op), node_op, _eo_op_id_name_get(node_op)); return NULL; @@ -340,29 +345,65 @@ _eo_kls_itr_reached_end(const Eo_Kls_Itr *cur) return !(*kls_itr && *(kls_itr + 1)); } +static inline const op_type_funcs * +_eo_kls_itr_func_get(const Eo_Class *klass, Eo_Kls_Itr *mro_itr, Eo_Op op, Eo_Kls_Itr *prev_state) +{ + _eo_kls_itr_init(klass, mro_itr, op, prev_state); + klass = _eo_kls_itr_get(mro_itr); + if (klass) + { + const op_type_funcs *func = _dich_func_get(klass, op); + + if (func && func->func) + { + return func; + } + } + + return NULL; +} + +#define _EO_OP_ERR_NO_OP_PRINT(op, klass) \ + do \ + { \ + const Eo_Class *op_klass = OP_CLASS_GET(op); \ + const char *_dom_name = (op_klass) ? op_klass->desc->name : NULL; \ + ERR("Can't find func for op %x ('%s' of domain '%s') for class '%s'. Aborting.", \ + op, _eo_op_id_name_get(op), _dom_name, \ + (klass) ? klass->desc->name : NULL); \ + } \ + while (0) + static Eina_Bool -_eo_op_internal(Eo *obj, Eina_Bool constant, Eo_Op op, va_list *p_list) +_eo_op_internal(Eo *obj, Eo_Op_Type op_type, Eo_Op op, va_list *p_list) { - const Eo_Class *klass; Eina_Bool ret = EINA_FALSE; +#ifndef NDEBUG const Eo_Op_Description *op_desc = _eo_op_id_desc_get(op); - if (op_desc && - ((constant == EINA_TRUE) && (op_desc->constant == EINA_FALSE))) + if (op_desc) { - ERR("Tried calling non-const or non-existant op '%s' (%d) from a const (query) function.", (op_desc) ? op_desc->name : NULL, op); - return EINA_FALSE; + if (op_desc->op_type == EO_OP_TYPE_CLASS) + { + ERR("Tried calling a class op '%s' (%x) from a non-class context.", (op_desc) ? op_desc->name : NULL, op); + return EINA_FALSE; + } + else if ((op_type == EO_OP_TYPE_CONST) && + (op_desc->op_type != EO_OP_TYPE_CONST)) + { + ERR("Tried calling non-const or non-existant op '%s' (%x) from a const (query) function.", (op_desc) ? op_desc->name : NULL, op); + return EINA_FALSE; + } } +#endif Eo_Kls_Itr prev_state; - _eo_kls_itr_init(obj->klass, &obj->mro_itr, op, &prev_state); - klass = _eo_kls_itr_get(&obj->mro_itr); - if (klass) - { - const op_type_funcs *func = _dich_func_get(klass, op); - if (func && func->func) + { + const op_type_funcs *func = + _eo_kls_itr_func_get(obj->klass, &obj->mro_itr, op, &prev_state); + if (func) { func->func(obj, _eo_data_get(obj, func->src), p_list); ret = EINA_TRUE; @@ -376,7 +417,7 @@ _eo_op_internal(Eo *obj, Eina_Bool constant, Eo_Op op, va_list *p_list) Eo *emb_obj; EINA_LIST_FOREACH(obj->composite_objects, itr, emb_obj) { - if (_eo_op_internal(emb_obj, constant, op, p_list)) + if (_eo_op_internal(emb_obj, op_type, op, p_list)) { ret = EINA_TRUE; goto end; @@ -390,7 +431,7 @@ end: } EAPI Eina_Bool -eo_do_internal(Eo *obj, Eina_Bool constant, ...) +eo_do_internal(Eo *obj, Eo_Op_Type op_type, ...) { Eina_Bool ret = EINA_TRUE; Eo_Op op = EO_NOOP; @@ -400,18 +441,14 @@ eo_do_internal(Eo *obj, Eina_Bool constant, ...) _eo_ref(obj); - va_start(p_list, constant); + va_start(p_list, op_type); op = va_arg(p_list, Eo_Op); while (op) { - if (!_eo_op_internal(obj, constant, op, &p_list)) + if (!_eo_op_internal(obj, op_type, op, &p_list)) { - const Eo_Class *op_klass = OP_CLASS_GET(op); - const char *_dom_name = (op_klass) ? op_klass->desc->name : NULL; - ERR("Can't find func for op %x ('%s' of domain '%s') for class '%s'. Aborting.", - op, _eo_op_id_name_get(op), _dom_name, - obj->klass->desc->name); + _EO_OP_ERR_NO_OP_PRINT(op, obj->klass); ret = EINA_FALSE; break; } @@ -425,27 +462,112 @@ eo_do_internal(Eo *obj, Eina_Bool constant, ...) } EAPI Eina_Bool -eo_do_super_internal(Eo *obj, Eina_Bool constant, Eo_Op op, ...) +eo_do_super_internal(Eo *obj, Eo_Op_Type op_type, Eo_Op op, ...) { - const Eo_Class *obj_klass; + const Eo_Class *nklass; Eina_Bool ret = EINA_TRUE; va_list p_list; EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE); /* Advance the kls itr. */ - obj_klass = _eo_kls_itr_next(&obj->mro_itr, op); + nklass = _eo_kls_itr_next(&obj->mro_itr, op); if (obj->mro_itr.op != op) return EINA_FALSE; va_start(p_list, op); - if (!_eo_op_internal(obj, constant, op, &p_list)) + if (!_eo_op_internal(obj, op_type, op, &p_list)) { - const Eo_Class *op_klass = OP_CLASS_GET(op); - const char *_dom_name = (op_klass) ? op_klass->desc->name : NULL; - ERR("Can't find func for op %x ('%s' of domain '%s') for class '%s'. Aborting.", - op, _eo_op_id_name_get(op), _dom_name, - (obj_klass) ? obj_klass->desc->name : NULL); + _EO_OP_ERR_NO_OP_PRINT(op, nklass); + ret = EINA_FALSE; + } + va_end(p_list); + + return ret; +} + +static Eina_Bool +_eo_class_op_internal(Eo_Class *klass, Eo_Op op, va_list *p_list) +{ + Eina_Bool ret = EINA_FALSE; + +#ifndef NDEBUG + const Eo_Op_Description *op_desc = _eo_op_id_desc_get(op); + + if (op_desc) + { + if (op_desc->op_type != EO_OP_TYPE_CLASS) + { + ERR("Tried calling an instance op '%s' (%x) from a class context.", (op_desc) ? op_desc->name : NULL, op); + return EINA_FALSE; + } + } +#endif + + Eo_Kls_Itr prev_state; + + { + const op_type_funcs *func = + _eo_kls_itr_func_get(klass, &klass->mro_itr, op, &prev_state); + if (func) + { + ((eo_op_func_type_class) func->func)(klass, p_list); + ret = EINA_TRUE; + goto end; + } + } + +end: + _eo_kls_itr_end(&klass->mro_itr, &prev_state); + return ret; +} + +EAPI Eina_Bool +eo_class_do_internal(const Eo_Class *klass, ...) +{ + Eina_Bool ret = EINA_TRUE; + Eo_Op op = EO_NOOP; + va_list p_list; + + EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, EINA_FALSE); + + va_start(p_list, klass); + + op = va_arg(p_list, Eo_Op); + while (op) + { + if (!_eo_class_op_internal((Eo_Class *) klass, op, &p_list)) + { + _EO_OP_ERR_NO_OP_PRINT(op, klass); + ret = EINA_FALSE; + break; + } + op = va_arg(p_list, Eo_Op); + } + + va_end(p_list); + + return ret; +} + +EAPI Eina_Bool +eo_class_do_super_internal(const Eo_Class *klass, Eo_Op op, ...) +{ + const Eo_Class *nklass; + Eina_Bool ret = EINA_TRUE; + va_list p_list; + EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, EINA_FALSE); + + /* Advance the kls itr. */ + nklass = _eo_kls_itr_next(&((Eo_Class *) klass)->mro_itr, op); + + if (klass->mro_itr.op != op) + return EINA_FALSE; + + va_start(p_list, op); + if (!_eo_class_op_internal((Eo_Class *) klass, op, &p_list)) + { + _EO_OP_ERR_NO_OP_PRINT(op, nklass); ret = EINA_FALSE; } va_end(p_list); @@ -476,8 +598,7 @@ _eo_class_base_op_init(Eo_Class *klass) if (!desc || !desc->ops.base_op_id) return; - /* FIXME: Depends on values defined above! */ - *(desc->ops.base_op_id) = klass->class_id << OP_CLASS_OFFSET; + *(desc->ops.base_op_id) = EO_CLASS_ID_TO_BASE_ID(klass->class_id); } #ifndef NDEBUG @@ -631,17 +752,26 @@ eo_class_funcs_set(Eo_Class *klass, const Eo_Op_Func_Description *func_descs) itr = func_descs; if (itr) { - for ( ; itr->op != 0 ; itr++) + for ( ; itr->op_type != EO_OP_TYPE_INVALID ; itr++) { const Eo_Op_Description *op_desc = _eo_op_id_desc_get(itr->op); - if (EINA_LIKELY(!op_desc || (itr->constant == op_desc->constant))) + if (EINA_UNLIKELY(!op_desc || (itr->op == EO_NOOP))) + { + ERR("Setting implementation for non-existent op %x for class '%s'. Func index: %d", itr->op, klass->desc->name, itr - func_descs); + } + else if (EINA_LIKELY(itr->op_type == op_desc->op_type)) { _dich_func_set(klass, itr->op, itr->func); } else { - ERR("Set function's constant property (%d) is different than the one in the op description (%d) for op '%s' in class '%s'.", itr->constant, op_desc->constant, op_desc->name, klass->desc->name); + ERR("Set function's op type (%x) is different than the one in the op description (%d) for op '%s' in class '%s'. Func index: %d", + itr->op_type, + (op_desc) ? op_desc->op_type : EO_OP_TYPE_REGULAR, + (op_desc) ? op_desc->name : NULL, + klass->desc->name, + itr - func_descs); } } } @@ -678,7 +808,7 @@ eo_class_free(Eo_Class *klass) /* DEVCHECK */ static Eina_Bool -_eo_class_check_op_descs(const Eo_Class *klass) +_eo_class_check_op_descs(const Eo_Class *klass, Eo_Class_Id id) { const Eo_Class_Description *desc = klass->desc; const Eo_Op_Description *itr; @@ -686,7 +816,7 @@ _eo_class_check_op_descs(const Eo_Class *klass) if (desc->ops.count > 0) { - if (!desc->ops.base_op_id) + if (((id == 0) || (id > EO_STATIC_IDS_LAST)) && !desc->ops.base_op_id) { ERR("Class '%s' has a non-zero ops count, but base_id is NULL.", desc->name); @@ -708,11 +838,11 @@ _eo_class_check_op_descs(const Eo_Class *klass) { if (itr->name) { - ERR("Wrong order in Ops description for class '%s'. Expected %d and got %d", desc->name, i, itr->sub_op); + ERR("Wrong order in Ops description for class '%s'. Expected %x and got %x", desc->name, i, itr->sub_op); } else { - ERR("Found too few Ops description for class '%s'. Expected %d descriptions, but found %d.", desc->name, desc->ops.count, i); + ERR("Found too few Ops description for class '%s'. Expected %x descriptions, but found %x.", desc->name, desc->ops.count, i); } return EINA_FALSE; } @@ -728,7 +858,7 @@ _eo_class_check_op_descs(const Eo_Class *klass) } EAPI const Eo_Class * -eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent, ...) +eo_class_new(const Eo_Class_Description *desc, Eo_Class_Id id, const Eo_Class *parent, ...) { Eo_Class *klass; va_list p_list; @@ -739,6 +869,12 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent, ...) return NULL; } + if (id > EO_STATIC_IDS_LAST) + { + ERR("Tried creating a class with the static id %d while the maximum static id is %d. Aborting.", id, EO_STATIC_IDS_LAST); + return NULL; + } + va_start(p_list, parent); EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL); @@ -821,7 +957,7 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent, ...) EO_ALIGN_SIZE(klass->parent->desc->data_size); } - if (!_eo_class_check_op_descs(klass)) + if (!_eo_class_check_op_descs(klass, id)) { goto cleanup; } @@ -873,11 +1009,36 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent, ...) } eina_lock_take(&_eo_class_creation_lock); - klass->class_id = ++_eo_classes_last_id; + + if (id == 0) + { + klass->class_id = ++_eo_classes_last_id; + } + else + { +#ifndef NDEBUG + if (_eo_classes && _eo_classes[id - 1]) + { + ERR("A class with id %d was already defined (%s). Aborting.", id, + _eo_classes[id - 1]->desc->name); + eina_lock_release(&_eo_class_creation_lock); + goto cleanup; + } +#endif + klass->class_id = id; + } + + { /* FIXME: Handle errors. */ + size_t arrsize = _eo_classes_last_id * sizeof(*_eo_classes); Eo_Class **tmp; - tmp = realloc(_eo_classes, _eo_classes_last_id * sizeof(*_eo_classes)); + tmp = realloc(_eo_classes, arrsize); + + /* If it's the first allocation, memset. */ + if (!_eo_classes) + memset(tmp, 0, arrsize); + _eo_classes = tmp; _eo_classes[klass->class_id - 1] = klass; } @@ -891,7 +1052,8 @@ eo_class_new(const Eo_Class_Description *desc, const Eo_Class *parent, ...) for ( ; *mro_itr ; mro_itr++) ; - for ( mro_itr-- ; mro_itr >= klass->mro ; mro_itr--) + /* Skip ourselves. */ + for ( mro_itr-- ; mro_itr > klass->mro ; mro_itr--) { _dich_copy_all(klass, *mro_itr); } @@ -910,6 +1072,43 @@ cleanup: return NULL; } +EAPI Eina_Bool +eo_parent_set(Eo *obj, const Eo *parent) +{ + EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE); + if (parent) + EO_MAGIC_RETURN_VAL(parent, EO_EINA_MAGIC, EINA_FALSE); + + if (obj->parent == parent) + return EINA_TRUE; + + _eo_ref(obj); + + if (eo_composite_is(obj)) + { + eo_composite_object_detach(obj->parent, obj); + } + + if (obj->parent) + { + obj->parent->children = + eina_inlist_remove(obj->parent->children, EINA_INLIST_GET(obj)); + eo_xunref(obj, obj->parent); + } + + obj->parent = (Eo *) parent; + if (obj->parent) + { + obj->parent->children = + eina_inlist_append(obj->parent->children, EINA_INLIST_GET(obj)); + eo_xref(obj, obj->parent); + } + + _eo_unref(obj); + + return EINA_TRUE; +} + EAPI Eo * eo_add(const Eo_Class *klass, Eo *parent) { @@ -926,17 +1125,17 @@ eo_add(const Eo_Class *klass, Eo *parent) Eo *obj = calloc(1, EO_ALIGN_SIZE(sizeof(*obj)) + (klass->data_offset + EO_ALIGN_SIZE(klass->desc->data_size)) + klass->extn_data_size); + EINA_MAGIC_SET(obj, EO_EINA_MAGIC); + obj->refcount++; obj->klass = klass; - obj->parent = parent; - obj->refcount++; + eo_parent_set(obj, parent); Eo_Kls_Itr prev_state; _eo_kls_itr_init(klass, &obj->mro_itr, EO_NOOP, &prev_state); _eo_error_unset(obj); - EINA_MAGIC_SET(obj, EO_EINA_MAGIC); _eo_ref(obj); _eo_constructor(obj, klass); @@ -985,7 +1184,6 @@ eo_xref_internal(Eo *obj, const Eo *ref_obj, const char *file, int line) xref->file = file; xref->line = line; - /* FIXME: Make it sorted. */ obj->xrefs = eina_inlist_prepend(obj->xrefs, EINA_INLIST_GET(xref)); #else (void) ref_obj; @@ -1040,16 +1238,13 @@ eo_ref(const Eo *_obj) return _eo_ref(obj); } -static void +static inline void _eo_del_internal(Eo *obj) { - if (obj->del) - return; /* We need that for the event callbacks that may ref/unref. */ obj->refcount++; eo_do(obj, eo_event_callback_call(EO_EV_DEL, NULL, NULL)); - obj->del = EINA_TRUE; const Eo_Class *klass = eo_class_get(obj); Eo_Kls_Itr prev_state; @@ -1069,36 +1264,59 @@ _eo_del_internal(Eo *obj) _eo_kls_itr_end(&obj->mro_itr, &prev_state); /*FIXME: add eo_class_unref(klass) ? - just to clear the caches. */ - Eina_List *itr, *itr_n; - Eo *emb_obj; - EINA_LIST_FOREACH_SAFE(obj->composite_objects, itr, itr_n, emb_obj) { - eo_composite_object_detach(obj, emb_obj); + Eina_List *itr, *itr_n; + Eo *emb_obj; + EINA_LIST_FOREACH_SAFE(obj->composite_objects, itr, itr_n, emb_obj) + { + eo_composite_object_detach(obj, emb_obj); + } } + while (obj->children) + { + eo_parent_set(EINA_INLIST_CONTAINER_GET(obj->children, Eo), NULL); + } + + obj->del = EINA_TRUE; obj->refcount--; } static inline void +_eo_free(Eo *obj) +{ + EINA_MAGIC_SET(obj, EO_FREED_EINA_MAGIC); + free(obj); +} + +static inline void _eo_unref(Eo *obj) { if (--(obj->refcount) == 0) { + if (obj->del) + { + ERR("Object %p already deleted.", obj); + return; + } + _eo_del_internal(obj); #ifndef NDEBUG - /* If for some reason it's not empty, clear it. */ - while (obj->xrefs) - { - WRN("obj->xrefs is not empty, possibly a bug, please report. - An error will be reported for each xref in the stack."); - Eina_Inlist *nitr = obj->xrefs->next; - free(EINA_INLIST_CONTAINER_GET(obj->xrefs, Eo_Xref_Node)); - obj->xrefs = nitr; - } + /* If for some reason it's not empty, clear it. */ + while (obj->xrefs) + { + WRN("obj->xrefs is not empty, possibly a bug, please report. - An error will be reported for each xref in the stack."); + Eina_Inlist *nitr = obj->xrefs->next; + free(EINA_INLIST_CONTAINER_GET(obj->xrefs, Eo_Xref_Node)); + obj->xrefs = nitr; + } #endif - EINA_MAGIC_SET(obj, EO_DELETED_EINA_MAGIC); - free(obj); + if (!obj->manual_free) + _eo_free(obj); + else + _eo_ref(obj); /* If we manual free, we keep a phantom ref. */ } } @@ -1111,6 +1329,13 @@ eo_unref(const Eo *_obj) _eo_unref(obj); } +EAPI void +eo_del(const Eo *obj) +{ + eo_parent_set((Eo *) obj, NULL); + eo_unref(obj); +} + EAPI int eo_ref_get(const Eo *obj) { @@ -1119,15 +1344,6 @@ eo_ref_get(const Eo *obj) return obj->refcount; } -EAPI void -eo_del(Eo *obj) -{ - EO_MAGIC_RETURN(obj, EO_EINA_MAGIC); - - _eo_del_internal(obj); - _eo_unref(obj); -} - EAPI Eo * eo_parent_get(const Eo *obj) { @@ -1263,10 +1479,12 @@ eo_data_get(const Eo *obj, const Eo_Class *klass) ret = _eo_data_get(obj, klass); +#ifndef NDEBUG if (!ret && (klass->desc->data_size == 0)) { ERR("Tried getting data of class '%s', but it has none..", klass->desc->name); } +#endif return ret; } @@ -1281,7 +1499,7 @@ eo_init(void) eina_init(); _eo_classes = NULL; - _eo_classes_last_id = 0; + _eo_classes_last_id = EO_STATIC_IDS_LAST; _eo_log_dom = eina_log_domain_register(log_dom, EINA_COLOR_LIGHTBLUE); if (_eo_log_dom < 0) { @@ -1296,8 +1514,8 @@ eo_init(void) } eina_magic_string_static_set(EO_EINA_MAGIC, EO_EINA_MAGIC_STR); - eina_magic_string_static_set(EO_DELETED_EINA_MAGIC, - EO_DELETED_EINA_MAGIC_STR); + eina_magic_string_static_set(EO_FREED_EINA_MAGIC, + EO_FREED_EINA_MAGIC_STR); eina_magic_string_static_set(EO_CLASS_EINA_MAGIC, EO_CLASS_EINA_MAGIC_STR); @@ -1337,7 +1555,8 @@ eo_composite_object_attach(Eo *obj, Eo *emb_obj) EO_MAGIC_RETURN(obj, EO_EINA_MAGIC); EO_MAGIC_RETURN(emb_obj, EO_EINA_MAGIC); - eo_xref(emb_obj, obj); + emb_obj->composite = EINA_TRUE; + eo_parent_set(emb_obj, obj); obj->composite_objects = eina_list_prepend(obj->composite_objects, emb_obj); } @@ -1347,12 +1566,13 @@ eo_composite_object_detach(Eo *obj, Eo *emb_obj) EO_MAGIC_RETURN(obj, EO_EINA_MAGIC); EO_MAGIC_RETURN(emb_obj, EO_EINA_MAGIC); + emb_obj->composite = EINA_FALSE; obj->composite_objects = eina_list_remove(obj->composite_objects, emb_obj); - eo_xunref(emb_obj, obj); + eo_parent_set(emb_obj, NULL); } EAPI Eina_Bool -eo_composite_is(Eo *emb_obj) +eo_composite_is(const Eo *emb_obj) { if (!EINA_MAGIC_CHECK(emb_obj, EO_EINA_MAGIC)) { @@ -1360,20 +1580,33 @@ eo_composite_is(Eo *emb_obj) return EINA_FALSE; } - Eo *obj = eo_parent_get(emb_obj); - Eina_List *itr; - Eo *tmp; + return emb_obj->composite; +} - if (!obj) - return EINA_FALSE; +EAPI void +eo_manual_free_set(Eo *obj, Eina_Bool manual_free) +{ + EO_MAGIC_RETURN(obj, EO_EINA_MAGIC); + obj->manual_free = manual_free; +} + +EAPI void +eo_manual_free(Eo *obj) +{ + EO_MAGIC_RETURN(obj, EO_EINA_MAGIC); + + if (EINA_FALSE == obj->manual_free) + { + ERR("Tried to manually free the object %p while the option has not been set; see eo_manual_free_set for more information.", obj); + return; + } - EINA_LIST_FOREACH(obj->composite_objects, itr, tmp) + if (!obj->del) { - if (tmp == emb_obj) - return EINA_TRUE; + ERR("Tried deleting the object %p while still referenced(%d).", obj, eo_ref_get(obj)); + return; } - return EINA_FALSE; + _eo_free(obj); } -