Object Identity Stuff
---------------------

It turns out that preserving object identity is not particularly
an easy feat especially when dealing with objects (instances of
classes) and logical primitives (instances of primitive programming
types). The OMF supports primitives, enumerations, structures,
containers and objects in a consistent, dynamic system. The only
problem is determining the identity of, say an object versus a
primitive.

A common solution seems to be the usage of hash-codes to return
integral values representing the unique identity of each object.
For example, we might consider the hash of an object (instantiated
class) to be the integer value of its pointer. Meanwhile we could
consider the identity of an integer or string to be its relevant
hash.

There may be an issue with generating hashes for pointers... G++
uses some weird floating pointer value in association with virtual
derivations (as far as I know). That means the pointer values for
different pointers to different types of the same object may be
different. For example:

class A {};
class B : virtual public A {};

B *b = new B;	// 0x8040
A *a = b;	// 0x8020

or something like that...

However, implementing the hash for ALL object types (as opposed
to integral, string, boolean or containers, enums and structures)
might be done in a particular interface (i.e., OMF::ModelObject).
Calling the identity() method through any derived interface should
return the same object identity. It should be fine.

Here's my plan for hashing different types of classes within
the OMF:

primitives: implement a simple string hash for all primitive types
containers: return the pointer value of the container
structures: undecided
enumerations: probably the same as primitives
objects: return the pointer value of the object

For the time being, using the pointer value of the allocated
container is probably acceptable. I can't think of any instances
off the top of my head where the uniqueness of containers would
be in question.