linked list with signals

[srdja]

linked list with signals

[mame98]

Yeah seems right... I will work on your solution tomorrow...

[mame98]

Yeah, I will work on this soon...

[ankurdh]

Hi @mame98 ,

Thats a good point. I think it's the best to implement a wrapper around the base linked list. This will help us keep the linked list clean with only the functions it's supposed to provide.

• Ankur

[srdja]

This is not bad idea. The most convinient way to implement this would be to keep the callback pointers in the container structure and just call them from appropriate functions if they are set. Two extra pointers shouldn't make much of a difference unless you're using lots of small containers, where the container structures themselves use a significant portion memory.

So basically if you wanted to set a callback you would do something like this:

ArrayConf ac;
array_conf_init(&ac);

ac.on_add     = my_add_callback;
ac.on_remove  = my_remove_callback;

Array *array;
array_new_conf(&ac, &array); // make a new array with this configuration

This is pretty easy to implement. We just need to add some extra function pointers to container and conf structures and then make sure to call them from appropriate function if they are set.

enum cc_stat array_add(Array *a, void *e) {
    ....
    if (a->on_add) 
        a->on_add() // call if set
}

... and so on

[mame98]

Okay, I think the way @ankurdh suggested is a bit better, because as you said that if you do not want the callbacks you are wasting memory.
You would just need to have some small wrapper functions which call the list functions but also trigger the callbacks...

So I would create a small structure like:

typedef struct
{
    List *list;
    on_add;
    on_delete;
    and so on...
}WatchList;

Then you would just implement an (inline) function to get the List from this WatchList. Also if there would be a small function to convert a 'normal' list to a WatchList it would be pretty easy to use...

What do you think?

[srdja]

I don't think that the solution @ankurdh proposed is practical. For one you wouldn't be able to use a List and WatchList interchangeably. Any peace of code that expects a List wouldn't be able to use the WatchList because its essentially a different container with a different API. Another thing is that the wrapper seems redundant because if the caller already knows that it's calling a function that will trigger a callback then you might as well just pass a regular List and a callback to that caller. The point is that this approach just needlessly complicates matters without much benefit.

This type of thing makes sense in languages that have some kind of inheritance where you can pass around a super type and where you can have modified behaviour in sub types, but trying to do this in C is really ugly.