!

[Mark Waddingham]

On 2016-03-31 18:06, Richard Gaskin wrote:
> When we use array syntax on custom property sets we have effectively a
> sort of two-dimensional array.  Would be nice to extend that deeper,
> but I'll take what I get.

Well, that 'anomaly' is basically about the fact that custom property 
set syntax is 'the wrong way round' (in some sense) to allow arbitrarily 
nested [] on custom properties to work. If custom property sets had 
never existed, and you just had custom properties, then we could have 
had:

   the foo of tObject - the foo custom property
   the foo["bar"] of tObject - the bar key of the (array valued) foo 
custom property
   the foo["bar"]["baz"] of tObject - the baz key of the bar key of the 
(array valued) foo custom property

However, what we have is:

   the foo of tObject - the foo custom property
   the foo["bar"] of tObject - the bar custom property in the foo custom 
property set

The second form here is very different from the second form above. This 
is a bit of a shame really, as it would have been much easier to think 
about if we could have made the equivalence:

   the foo[a]...[z] of tObject === (the foo of tObject)[a]...[z]

> But when we put an array into a custom property value such as:
> 
> put "foo" into bar[1]
> set the uBar of btn 1 to bar
> 
> ...it seems we can store that even though it hasn't been explicitly 
> serialized.
> 
> So my hunch is that when we do that the engine is using the same
> serialization it uses for arrayEncode, and when retrieving the array
> it automatically runs it through the internal equivalent of
> arrayDecode.
> 
> Is that correct?

Well, implementation-wise, the 'default custom property set' is the 
custom property set with name 'empty'; and internally each object has a 
linked list of named custom property sets. Each custom property set does 
and always had the same representational power as a LiveCode variable. 
So when nested arrays were added, custom properties gained the ability 
to hold arrays too. Since 7, all a custom property set is is a (name, 
array) pair, where the array part maps custom property names in that set 
to their values.

> If not, by what sorcery are array values serialized when stored as
> persistent property values?

Well, there was a fair bit of sorcery involved way back when nested 
arrays were added as we wanted to try and squeeze them into the file 
format without breaking backwards compatibility.

However, the principal motivation (if I remember correctly, at least - 
we are going back many many years here) for arrayEncoding was to enable 
custom property sets to serialize array values.

Anyway, to summarise, when in memory a custom property set is just an 
array (which is looked up in a linked list by name) - this array maps 
custom property names to values. When written out to disk (in 7+ format 
- pre-6.7 format had to do horrendous things which I never want to have 
to look at again) each custom property set is serialized as the name 
followed by the arrayEncoding of the array.

Hopefully that all makes sense...

Mark.

-- 
Mark Waddingham ~ mark at livecode.com ~ http://www.livecode.com/
LiveCode: Everyone can create apps