anchor.diff:  import "../datastore/key.dart";
   import "../datastore/query.dart";
   
  +typedef T ModelFactory<T>();
  +
   /// Maps entity model objects of a certain type to [Entity] objects and back.
   ///
   /// The type parameter [T] must be the same class that is passed to the constructor
  
positive.code:   ///
    /// Normally there's no need to use this constructor, the cached object
    /// should do every time.
    factory EntityBridge.uniqueFromClass(Type type) {
      EntityMetadataBuilder b = new EntityMetadataBuilder.fromClass(type);
      return new EntityBridge._(
          b.descriptor,
          b.kind,
          b.key,
          new Map.unmodifiable(b.propertyMetadata),
          new List.unmodifiable(b.versionFields));
    }
  
    EntityBridge._(this.descriptor, this.kind, this._key, this._propertyMetadata,
        this._versionFields);
  
    Key createKey({String name, int id, Key parent}) =>
        new Key(kind, name: name, id: id, parent: parent);
  
negative.code: class EntityBridge<T> {
    /// Constructs or returns a cached [EntityBridge] object based on
    /// the type parameter [T].
    factory EntityBridge({ModelFactory<T> modelFactory}) {
      return new EntityBridge<T>.fromClass(T, modelFactory: modelFactory);
    }
  
    /// Constructs an entity mapper object based on [type].
    ///
    /// Uses an internal cache of [EntityBridge] objects.
    factory EntityBridge.fromClass(Type type, {ModelFactory<T> modelFactory}) {
      EntityBridge<T> result = _cachedBridges[type];
      if (result != null) return result;
      result = new EntityBridge.uniqueFromClass(type, modelFactory: modelFactory);
      _cachedBridges[type] = result;
      return result;
    }
  