Next: Persistent Vats, Previous: Persistence capable objects, Up: Persistence [Contents][Index]
Using the persistence support on an actormap allows for taking a portrait of its current state, rehydrating that state into an actormap and updating the behavior of an object through an upgrade mechanism.
Takes a portrait of the objects within the actormap starting with the supplied roots.
This takes an actormap, am which contains the objects and an persistence-env which describes some additional information about all the objects within the graph that’s needed to support persistence. The final arguments are all the roots within the graph.
The portrait is a map where each object within the portrait that is represented by an integer which maps to its respective portrait data (in a serializable form), this integer is known as a slot. When an object contains a reference to another object, that object is referred to by its slot.
The procedure returns two values to its continuation, those are:
1. the self portrait data 2. the root slots: these are in order the integers of the root objects.
This restores the objects in the actormap am from the portrait data portrait-data using the object specifications data stored in persistence-env with the given roots.
Due to the way rehydration of depictions works each object is represented as a vow which will be resolved when returned.
This procedure returns to the continuation all the references to the restored objects for the given roots. This is so that the number of values returned is equal to the number of roots provided.
Replace actors in actormap am with new behavior from persistence-env
It’s often desirable, especially when developing a system, to update or otherwise change the behavior of objects which already exist in an actormap. This can easily be done by using the persistence system in Goblins. Each object can describe itself through its self portrait and then be rehydrated into its new behavior allowing seamless upgrades.
This procedure will first calculate all of the objects that have an updated constructor within persistence-env. It will then take a portrait all those objects, then using that portrait data, rehydrate them with the new behavior keeping the object references the same.
It’s important to note that in order to be able to replace the
behavior the objects must be been defined as redefinable, this is
commonly done by using the define-hackable macro provided with
Goblins. Non-redefinable actors will not have their behavior replaced
as they will appear as different objects within the
persistence-env.
Functional version of actormap-replace-behavior!
This works the same as ‘actormap-replace-behavior!’ but it returns a transactormap which the user can choose whether or not to commit.
Next: Persistent Vats, Previous: Persistence capable objects, Up: Persistence [Contents][Index]