Ok, lets see here....

When designing complex systems, it is often preferable to break things down into smaller and smaller interconnecting parts until they become "atomic". This is the point at which the problem can not be broken down any further and this part has to exist (irreducible) in order for the system to function. Sometimes this "atom" can itself be complex (irreducible complexity).

So by "atomizing" the large complex problem we then get a series of smaller goals that we need to achieve that are less dependent on each other and thus more manageable. They can be thoroughly debugged and more or less be forgotten about. This is what we are after. If were to go with the approach that an object can completely save/load itself than any object derived from this base object type can completely save/load itself no matter how complex it may become. Because this "atomic" part just works it removes itself from the overall complexity of the solution. If we discover a bug in this area and fix it, it is more or less guaranteed to work correctly all the way up the chain.

At this point you no longer have to think about how objects are stored, just the fact that they can save/load themselves. If I can save/load myself I can easily be assigned to another object of the same type or derived from the same type.

Let look at this:

Say I have ObjectA and ObjectB which is derived from ObjectA. So ObjectB would be a superset of ObjectA with additional data and both objects "know" how to save/load themselves. if I assign ObjectB to ObjectA then we need to be able to call the inherited method of ObjectB that can save the ObjectA level data to the stream. I have to do some test to see how to figure out which inherited method to call based on the derived object passed in. But my point here is that if we can get this working correctly then you should be able to assign one object to another and it will copy the data it has in common. At present it will be able to duplicate itself if you pass in the same type. I just need to figure out a way to save the parts that they have in common for a complete object assignment solution.

I know on the surface this seems more completed than it should be, but it's really not. The complication at this point is in thoroughly defining our goal first of all and over coming any limitations imposed by the compiler to archive this goal. I wanted to attack the problem from a software engineering perspective so that we can apply what's been learned going forward.

Ahhhh.. brain hurts gotta do some more thinking....