for inverse attrs, we have the attr name and the type of the instance

--load instance, find inverse attr(s)
--for each inverse attr:
--find all instance types that inherit from the inverted attr's owner (list A)
--look up instances that reference the one in question (list B) - use memoization
--find instances that match both lists, put in list C
--load instances in list C
--for list C, check that the relevant attr references the original instance - if not, unload (?)
--

--when done with this inverse attr, cache list A




EXAMPLE
*******

information model
-----------------
    ENTITY Object;
        ObjectType : OPTIONAL STRING;
    INVERSE
        IsDefinedBy : SET [0:?] OF RelDefinesByType FOR RelatedObjects;
    END_ENTITY;

    ENTITY RelDefinesByType;
        RelatedObjects : SET [1:?] OF Object;
    END_ENTITY;

    ENTITY Window
        SUBTYPE OF (Object);
        Description : OPTIONAL string;
    END_ENTITY;

data file
---------
    #1=OBJECT('one');
    #2=RELDEFINESBYTYPE((#1));
    #3=RELDEFINESBYTYPE((#4));
    #4=WINDOW('two','blah');

#1 and #4 have an inverse attr, but this is not visible in the data file
#2 and #3 have #1 and #4, respectively, in an aggregate (thus the parenthesis around the instance); in this case, a SET called RelatedObjects
RelatedObjects is the inverted attr that the inverse attr IsDefinedBy links to

looking at the entity descriptor for WINDOW, it is not apparent that there is an inverse attr; its parents must be examined


given inverted attr ia:
attr method                     value
-----------                     -----
ia->Name()                    isdefinedby
ia->inverted_attr_id_()       relatedobjects
ia->inverted_entity_id_()     reldefinesbytype

1. for the instance in question, find inverse attrs with recursion
2. for each ia,
  a. entity name is returned by ia->inverted_entity_id_()
  b. add this entity and its children to a list (list A)
  c. look up references to the current instance (list B)
  d. for each item in B, look up its type; if its type is present in A, remember the instance number (list C)
  e. load each instance in C
  f. (optional) check if the relevant inverted attr of instances loaded from list C reference the instance in step 1; if not, unload **IF** the instance hadn't been loaded
     --> if it was loaded, this implies that it is used elsewhere
  g. cache list A, since it may be useful in the future
     -- best to store such that the most recently (frequently?) used lists are retained and others are discarded


NEED TO DO
----------
make it possible to access inverse attrs without knowing their names
probably best to do this much like explicit attrs - creating an array. each element should have a pointer to the inverted attr desc, a pointer to the setter, and a pointer to the getter
