code: public <T> List<DiffObjectHistoricalTransition<T>> getObjectHistory(String type, Object key) {
          List<DiffObjectHistoricalTransition<T>> states = new ArrayList<DiffObjectHistoricalTransition<T>>(historicalStates.size());
          Map<Object, T> typeState = currentDataState.getTypeState(type);
  
          /// start with the currently available item (if available)
          T currentItem = typeState.get(key);
  
          /// and work backwards through history.
          for(DiffHistoricalState state : historicalStates) {
  
              DiffHistoricalTypeState<Object, T> historicalState = state.getTypeState(type);
  
              Map<Object, T> diffObjects = historicalState.getDiffObjects();
              Map<Object, T> deletedObjects = historicalState.getDeletedObjects();
              Set<Object> newObjects = historicalState.getNewObjects();
  
              T previous;
  
              if(diffObjects.containsKey(key)) {
                  previous = diffObjects.get(key);
              } else if(deletedObjects.containsKey(key)) {
                  previous = deletedObjects.get(key);
              } else if(newObjects.contains(key)) {
                  previous = null;
              } else {
                  previous = currentItem;
              }
  
              /// adding the from -> to objects (whether identical or not) to a list.
              states.add(new DiffObjectHistoricalTransition<T>(state.getVersion(), previous, currentItem));
              currentItem = previous;
          }
  
          return states;
      }
docs: Return the history of the object identified by the supplied type / key combination.<p/>
  
  The returned list will contain one entry for each state in the rolling history retained by this DiffHistoryTracker.
  The latest entry will be at index 0, and the earliest entry will be the last in the list.  Not all entries in the returned
  list must reflect a transition; an entry is included in the list whether or not the instance changed for a given state.