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/KVZQ3VBBJNV5LHEBZNMKLTUS7AF2HJX7/
To unsubscribe send an email to pd-list-le...@lists.iem.at mailing list
UNSUBSCRIBE and account-management -> https://lists.iem.at/
---
pd-list@lists.iem.at - the Pure Data mailinglist
https://lists.iem.at/hyperkitty/list/pd-list@lists.iem.at/message/TSYAJLGLBO4NT6OL3J6TLU4EJLQQTEPW/
To unsubscribe send an email to pd-list-le...@lists.iem.at mailing list
UNSUBSCRIBE and account-management -> https://lists.iem.at/
