Create database-Like Transactions.

[MicahGale]

This idea came from a discussion in #54: https://hpcgitlab.hpc.inl.gov/experiment_analysis/mcnpy/-/issues/54#note_480927

In relation database theory (aka SQL databases, but don't tell the mathmeticians), there is a concept called "ACID":

• A — atomicity
• C — consistency
• I — isolation
• D — durability

I think the last three doesn't really matter when you are talking about a single user scenario. However, the concept of atomicity is interesting. This is usually accomplished through transactions where everything goes through or nothing does.

Generally this is handled by the following workflow:

1. start a transaction.
2. Start making changes
3. if error occurs: call a roll-back and undo all changes up to this point
4. If no errors occur: call a commit and all changes are simultaneously made available to all.

For MontePy I think this could look like:

try: 
   problem.start_transaction()
   .... do things
   problem.commit()
except e:
   problem.roll_back()

Realistically it should be implemented such that the following works:

with problem.start_transaction():
    do things...

and the roll back and commits are silent.

How to implement this could be a lot harder. Simplest way would be to just do a deepcopy when start_transaction() is called. When commit() is called that copy is discarded, but when roll_back is called that copy becomes the problem.

To avoid performance issues I think #83 needs to be implemented first.

[MicahGale]

marked this issue as related to #51

[MicahGale]

marked this issue as related to #83

[MicahGale]

removed the relation with #51

[MicahGale]

marked this issue as related to #54