Using pickle for in-memory "transaction"?

A user can perform an action, which may trigger dependent actions (which themselves may have dependent actions) and I want to be able to cancel the whole thing if the user cancels a dependent action.

The typical way I've seen this done is some variant of an undo stack and each action will need to know how to undo itself, and then if a child action is cancelled the undo's cascade their way up. Sometimes writing undo methods are tricky and there isn't always enough information in context to properly know how to undo an action in an isolat开发者_如何学运维ed manner.

I just thought of a (potentially) easier way which is to just pickle the state of the (relevant parts of) program, and then the cancel would just restore to it's former state, without needing to create separate undo logic for each action.

Has anyone tried this? Any gotchas to watch out for? Any reason not to do this?

Edit: The dependent actions must happen after the parent action (and even whether there are dependent actions may depend on the result of the parent action), so just checking all the dependencies before doing anything isn't an option. I guess you could say an action triggers other actions, but if one of the triggered actions cannot be performed, then none of it happened.

Well, as you mentioned the data design is loosely coupled, so you I don't think you need to pickle it if it's in memory. Just take a copy of all the relevant variables, and the transaction.abort() would just copy them back, and transaction.commit() would then just remove the copy of the data.

There are issues, but none that you don't have with the pickle solution.

You can use pickle to store your state if all elements of state are serializable (usually they are). The only reasons for not doing so:

• if you have to store pointers to any objects that are not saved in state, you will have problems with these pointers after performing undo operation.

• this method could be expensive, depending on the size of your state.

Also you can use zip() to lower memory usage in exchange of raising CPU usage.