Hi,
I want to use STON to enable the backup a graph of objects pertaining to an
application.
Some of the objects in this graph include, in their state, a Map that is
not supported by STON.
To write these objects, I would like to write via the standard procedure
all the instance variables unless that pointing to such a map, and then add
a modified version of that map by hand.
To exclude the conflicting variable is easy, I just redefine
#stonAllInstVarNames at the class side as follows:
^self instVarNames reject: [ :theName | (theName = #references) ]
in this way, I do not need to modify the method if the state of these
objects changes.
On the other hand, I found not easy to use the standard mechanism for the
included instance variables. This mechanism is embedded in
STONWriter>>writeObject: . I found no option but repeat the logic codified
there, in the method #stonOn: of my class.
The easiest way to let STON integrate the standard mechanism to store the
state of an object, with by-hand additions, is to slightly modify
STONWriter>>writeObject:, adding just one line. Objects including instance
variables would be written as follows:
self writeObject: anObject streamMap: [ :dictionary |
instanceVariableNames do: [ :each |
(anObject instVarNamed: each)
ifNotNil: [ :value |
dictionary at: each asSymbol put: value ]
ifNil: [
anObject stonShouldWriteNilInstVars
ifTrue: [ dictionary at: each asSymbol put: nil ] ] ] .
anObject stonAdditionalInfoOn: dictionary . ]
the added line is the last one, the invocation to #stonAdditionalInfoOn:.
Of course, the method #stonAdditionalInfoOn: should be added to the Object
class.
By redefining this method in my class, I was able to easily add the
modified, STON-compatlble value, to the values handled by the STON code.
I did not need to modify the STON code to read the STON String to generate
a new object.
Do you think that doing this modification to STON could be a good idea?
Cordially - Carlos
PS: I envisaged as an alternative, to allow the following method in my class
stonOn:stonWriter
stonWriter writeObjectAsMap: self
do: [:mapWriter |
// added code goes here
stonWriter writeInstVarsOf: self on: mapWriter
// added code goes here
]
To this end, the methods #writeObjectAsMap:do: and #writeInstVarsOf:on
should be added to STONWriter. The method
writeInstVar: aSymbol of: anObject on: mapWriter
could be offered as well, to allow more fine-grained redefinitions of
stonOn: , while keeping the ability to use the standard mechanism to store
an instance variable.
I think that the option I described earlier is simpler, I include this one
because maybe other people would prefere it.
