Hi,

yes, it's a design choice. A "gpointer" is basically a safe handle to a data structure object (scalar or array) and as such it has to know when it has been invalidated. There are several ways to implement this.

For example, every data structure object could maintain a list of all gpointers that currently reference it. When the object is deleted, it would have to notify all "gpointers". Conversely, when a gpointer is set to another object, it has to unregister from the old object and register to the new one. In C, gpointers and stubs are represented by the "t_gpointer" resp. "t_gstub" structs (see m_pd.h)

Miller chose a simpler solution: every canvas has a "stub" object with a reference count and a generation counter. When you set a gpointer, it not only saves a pointer to the data structure object, it also keeps a reference to the stub of the owning canvas. When a data structure object is deleted, the stub's generation counter is incremented and as a consequence all existing gpointers to *any* data structure object in that canvas are invalidated.

Unfortunately, since "t_gpointer" and "t_scalar" are public structs, I don't think there is a way to change the implementation without breaking backwards compatibility. I'm not even sure it would be worth the additional complexity.

Actually, I have had the same problem as you. The solution I've found is to never actually delete the scalars, instead I made the scalar invisible and set a special field inside scalar. When I wanted to create a scalar, I first traversed the canvas to see if there is already a "dead" scalar I could reuse. Of course, this only works as long as the user never *directly* deletes the scalars (e.g. with select + delete). Otherwise, the only solution is to re-traverse the canvas and update all your [pointer] objects...

Christof

On 19.10.2024 22:45, Jean-Yves Gratius wrote:

Hi,

I wonder why, in data structures, deleting a scalar invalidates all pointers to any other scalar in the same canvas.

Is this a design choice ?

I'm asking this because I planned to use pointers inside abstractions to handle scalars in a patch, for example for making them move.

But may be I'm wrong, because if every time a scalar is deleted all [pointer]s have to [traverse( the patch to retrieve the scalar they pointed to, it seems not so optimized.

Thanks in advance

Regards

JYG

---

pd-list@lists.iem.at - the Pure Data mailinglist https://lists.iem.at/hyperkitty/list/pd-list@lists.iem.at/message/KVZQ3VBBJN...

To unsubscribe send an email to pd-list-leave@lists.iem.at mailing list UNSUBSCRIBE and account-management -> https://lists.iem.at/