breeze-client 2.1.2 → 2.1.3-mjs

package/esm2020/src/entity-group.mjs

@@ -0,0 +1,187 @@
+import { DataProperty } from './entity-metadata';
+import { EntityKey } from './entity-key';
+import { EntityState } from './entity-state';
+import { MergeStrategy } from './query-options';
+/** @hidden @internal */
+export class EntityGroup {
+    constructor(entityManager, entityType) {
+        this.entityManager = entityManager;
+        this.entityType = entityType;
+        // freeze the entityType after the first instance of this type is either created or queried.
+        this.entityType.isFrozen = true;
+        this._indexMap = {};
+        this._entities = [];
+        this._emptyIndexes = [];
+    }
+    attachEntity(entity, entityState, mergeStrategy) {
+        // entity should already have an aspect.
+        let aspect = entity.entityAspect;
+        if (!aspect._initialized) {
+            this.entityType._initializeInstance(entity);
+        }
+        delete aspect._initialized;
+        let keyInGroup = aspect.getKey()._keyInGroup;
+        let ix = this._indexMap[keyInGroup];
+        if (ix >= 0) {
+            // safecast because key was found not ix will not return a null
+            let targetEntity = this._entities[ix];
+            let targetEntityState = targetEntity.entityAspect.entityState;
+            let wasUnchanged = targetEntityState.isUnchanged();
+            if (targetEntity === entity) {
+                aspect.entityState = entityState;
+            }
+            else if (mergeStrategy === MergeStrategy.Disallowed) {
+                throw new Error("A MergeStrategy of 'Disallowed' does not allow you to attach an entity when an entity with the same key is already attached: " + aspect.getKey());
+            }
+            else if (mergeStrategy === MergeStrategy.OverwriteChanges || (mergeStrategy === MergeStrategy.PreserveChanges && wasUnchanged)) {
+                // unwrapInstance returns an entity with server side property names - so we need to use DataProperty.getRawValueFromServer these when we apply
+                // the property values back to the target.
+                let rawServerEntity = this.entityManager.helper.unwrapInstance(entity);
+                this.entityType._updateTargetFromRaw(targetEntity, rawServerEntity, DataProperty.getRawValueFromServer);
+                targetEntity.entityAspect.setEntityState(entityState);
+            }
+            return targetEntity;
+        }
+        else {
+            if (this._emptyIndexes.length === 0) {
+                ix = this._entities.push(entity) - 1;
+            }
+            else {
+                ix = this._emptyIndexes.pop();
+                this._entities[ix] = entity;
+            }
+            this._indexMap[keyInGroup] = ix;
+            aspect.entityState = entityState;
+            aspect.entityGroup = this;
+            aspect.entityManager = this.entityManager;
+            return entity;
+        }
+    }
+    detachEntity(entity) {
+        // by this point we have already determined that this entity
+        // belongs to this group.
+        let aspect = entity.entityAspect;
+        let keyInGroup = aspect.getKey()._keyInGroup;
+        let ix = this._indexMap[keyInGroup];
+        if (ix === undefined) {
+            // shouldn't happen.
+            throw new Error("internal error - entity cannot be found in group");
+        }
+        delete this._indexMap[keyInGroup];
+        this._emptyIndexes.push(ix);
+        this._entities[ix] = null;
+        return entity;
+    }
+    // returns entity based on an entity key defined either as an array of key values or an EntityKey
+    findEntityByKey(entityKey) {
+        let keyInGroup;
+        if (entityKey instanceof EntityKey) {
+            keyInGroup = entityKey._keyInGroup;
+        }
+        else {
+            keyInGroup = EntityKey.createKeyString(entityKey);
+        }
+        let ix = this._indexMap[keyInGroup];
+        // can't use just (ix) below because 0 is valid
+        let r = (ix !== undefined) ? this._entities[ix] : undefined;
+        // coerce null to undefined
+        return r == null ? undefined : r;
+    }
+    hasChanges() {
+        let entities = this._entities;
+        let unchanged = EntityState.Unchanged;
+        for (let i = 0, len = entities.length; i < len; i++) {
+            let e = entities[i];
+            if (e && e.entityAspect.entityState !== unchanged) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getChanges() {
+        let entities = this._entities;
+        let unchanged = EntityState.Unchanged;
+        let changes = [];
+        for (let i = 0, len = entities.length; i < len; i++) {
+            let e = entities[i];
+            if (e && e.entityAspect.entityState !== unchanged) {
+                changes.push(e);
+            }
+        }
+        return changes;
+    }
+    getEntities(entityStates) {
+        let filter = getFilter(entityStates);
+        return this._entities.filter(filter);
+    }
+    _checkOperation(operationName) {
+        this._entities.forEach(function (entity) {
+            entity && entity.entityAspect._checkOperation(operationName);
+        });
+        // for chaining;
+        return this;
+    }
+    // do not expose this method. It is doing a special purpose INCOMPLETE fast detach operation
+    // just for the entityManager clear method - the entityGroup will be in an inconsistent state
+    // after this op, which is ok because it will be thrown away.
+    // TODO: rename this to be clear that it is UNSAFE...
+    _clear() {
+        this._entities.forEach(function (entity) {
+            if (entity != null) {
+                entity.entityAspect._detach();
+            }
+        });
+        this._entities = null;
+        this._indexMap = null;
+        this._emptyIndexes = null;
+    }
+    _updateFkVal(fkProp, oldValue, newValue) {
+        let fkPropName = fkProp.name;
+        this._entities.forEach(function (entity) {
+            if (entity != null) {
+                if (entity.getProperty(fkPropName) === oldValue) {
+                    entity.setProperty(fkPropName, newValue);
+                }
+            }
+        });
+    }
+    _fixupKey(tempValue, realValue) {
+        // single part keys appear directly in map
+        let ix = this._indexMap[tempValue];
+        if (ix === undefined) {
+            throw new Error("Internal Error in key fixup - unable to locate entity");
+        }
+        let entity = this._entities[ix];
+        let keyPropName = entity.entityType.keyProperties[0].name;
+        // fks on related entities will automatically get updated by this as well
+        entity.setProperty(keyPropName, realValue);
+        delete entity.entityAspect.hasTempKey;
+        delete this._indexMap[tempValue];
+        this._indexMap[realValue] = ix;
+    }
+    _replaceKey(oldKey, newKey) {
+        let ix = this._indexMap[oldKey._keyInGroup];
+        delete this._indexMap[oldKey._keyInGroup];
+        this._indexMap[newKey._keyInGroup] = ix;
+    }
+}
+function getFilter(entityStates) {
+    if (entityStates.length === 0) {
+        return function (e) {
+            return !!e;
+        };
+    }
+    else if (entityStates.length === 1) {
+        let entityState = entityStates[0];
+        return function (e) {
+            return !!e && e.entityAspect.entityState === entityState;
+        };
+    }
+    else {
+        return function (e) {
+            return !!e && -1 !== entityStates.indexOf(e.entityAspect.entityState);
+        };
+    }
+}
+// do not expose EntityGroup - internal only
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-group.js","sourceRoot":"","sources":["../../../src/entity-group.ts"],"names":[],"mappings":"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","sourcesContent":["import { Entity } from './entity-aspect';\r\nimport { EntityType, DataProperty  } from './entity-metadata';\r\nimport { EntityKey } from './entity-key';\r\nimport { EntityState } from './entity-state';\r\nimport { EntityManager } from './entity-manager';\r\nimport { MergeStrategy } from './query-options';\r\n\r\n/** @hidden @internal */\r\nexport class EntityGroup {\r\n  entityManager: EntityManager;\r\n  entityType: EntityType;\r\n  _indexMap: { [index: string]: number };\r\n  _entities: (Entity | null)[];\r\n  _emptyIndexes: number[];\r\n\r\n  constructor(entityManager: EntityManager, entityType: EntityType) {\r\n    this.entityManager = entityManager;\r\n    this.entityType = entityType;\r\n    // freeze the entityType after the first instance of this type is either created or queried.\r\n    this.entityType.isFrozen = true;\r\n    this._indexMap = {};\r\n    this._entities = [];\r\n    this._emptyIndexes = [];\r\n  }\r\n\r\n\r\n  attachEntity(entity: Entity, entityState: EntityState, mergeStrategy?: MergeStrategy) {\r\n    // entity should already have an aspect.\r\n    let aspect = entity.entityAspect;\r\n\r\n    if (!aspect._initialized) {\r\n      this.entityType._initializeInstance(entity);\r\n    }\r\n    delete aspect._initialized;\r\n\r\n    let keyInGroup = aspect.getKey()._keyInGroup;\r\n    let ix = this._indexMap[keyInGroup];\r\n    if (ix >= 0) {\r\n      // safecast because key was found not ix will not return a null\r\n      let targetEntity = this._entities[ix] as Entity;\r\n      let targetEntityState = targetEntity.entityAspect.entityState;\r\n      let wasUnchanged = targetEntityState.isUnchanged();\r\n      if (targetEntity === entity) {\r\n        aspect.entityState = entityState;\r\n      } else if (mergeStrategy === MergeStrategy.Disallowed) {\r\n        throw new Error(\"A MergeStrategy of 'Disallowed' does not allow you to attach an entity when an entity with the same key is already attached: \" + aspect.getKey());\r\n      } else if (mergeStrategy === MergeStrategy.OverwriteChanges || (mergeStrategy === MergeStrategy.PreserveChanges && wasUnchanged)) {\r\n        // unwrapInstance returns an entity with server side property names - so we need to use DataProperty.getRawValueFromServer these when we apply\r\n        // the property values back to the target.\r\n        let rawServerEntity = this.entityManager.helper.unwrapInstance(entity);\r\n        this.entityType._updateTargetFromRaw(targetEntity, rawServerEntity, DataProperty.getRawValueFromServer);\r\n        targetEntity.entityAspect.setEntityState(entityState);\r\n      }\r\n      return targetEntity;\r\n    } else {\r\n      if (this._emptyIndexes.length === 0) {\r\n        ix = this._entities.push(entity) - 1;\r\n      } else {\r\n        ix = this._emptyIndexes.pop();\r\n        this._entities[ix] = entity;\r\n      }\r\n      this._indexMap[keyInGroup] = ix;\r\n      aspect.entityState = entityState;\r\n      aspect.entityGroup = this;\r\n      aspect.entityManager = this.entityManager;\r\n      return entity;\r\n    }\r\n  }\r\n\r\n  detachEntity(entity: Entity) {\r\n    // by this point we have already determined that this entity\r\n    // belongs to this group.\r\n    let aspect = entity.entityAspect;\r\n    let keyInGroup = aspect.getKey()._keyInGroup;\r\n    let ix = this._indexMap[keyInGroup];\r\n    if (ix === undefined) {\r\n      // shouldn't happen.\r\n      throw new Error(\"internal error - entity cannot be found in group\");\r\n    }\r\n    delete this._indexMap[keyInGroup];\r\n    this._emptyIndexes.push(ix);\r\n    this._entities[ix] = null;\r\n    return entity;\r\n  }\r\n\r\n\r\n  // returns entity based on an entity key defined either as an array of key values or an EntityKey\r\n  findEntityByKey(entityKey: EntityKey) {\r\n    let keyInGroup: string;\r\n    if (entityKey instanceof EntityKey) {\r\n      keyInGroup = entityKey._keyInGroup;\r\n    } else {\r\n      keyInGroup = EntityKey.createKeyString(entityKey);\r\n    }\r\n    let ix = this._indexMap[keyInGroup];\r\n    // can't use just (ix) below because 0 is valid\r\n    let r = (ix !== undefined) ? this._entities[ix] : undefined;\r\n    // coerce null to undefined\r\n    return r == null ? undefined : r;\r\n  }\r\n\r\n  hasChanges() {\r\n    let entities = this._entities;\r\n    let unchanged = EntityState.Unchanged;\r\n    for (let i = 0, len = entities.length; i < len; i++) {\r\n      let e = entities[i];\r\n      if (e && e.entityAspect.entityState !== unchanged) {\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  getChanges() {\r\n    let entities = this._entities;\r\n    let unchanged = EntityState.Unchanged;\r\n    let changes: Entity[] = [];\r\n    for (let i = 0, len = entities.length; i < len; i++) {\r\n      let e = entities[i];\r\n      if (e && e.entityAspect.entityState !== unchanged) {\r\n        changes.push(e);\r\n      }\r\n    }\r\n    return changes;\r\n  }\r\n\r\n  getEntities(entityStates: EntityState[]) {\r\n    let filter = getFilter(entityStates);\r\n    return this._entities.filter(filter) as Entity[];\r\n  }\r\n\r\n  _checkOperation(operationName: string) {\r\n    this._entities.forEach(function (entity) {\r\n      entity && entity.entityAspect._checkOperation(operationName);\r\n    });\r\n    // for chaining;\r\n    return this;\r\n  }\r\n\r\n  // do not expose this method. It is doing a special purpose INCOMPLETE fast detach operation\r\n  // just for the entityManager clear method - the entityGroup will be in an inconsistent state\r\n  // after this op, which is ok because it will be thrown away.\r\n  // TODO: rename this to be clear that it is UNSAFE...\r\n  _clear() {\r\n    this._entities.forEach(function (entity) {\r\n      if (entity != null) {\r\n        entity.entityAspect._detach();\r\n      }\r\n    });\r\n    (this as any)._entities = null;\r\n    (this as any)._indexMap = null;\r\n    (this as any)._emptyIndexes = null;\r\n  }\r\n\r\n  _updateFkVal(fkProp: DataProperty, oldValue: any, newValue: any) {\r\n    let fkPropName = fkProp.name;\r\n    this._entities.forEach(function (entity) {\r\n      if (entity != null) {\r\n        if (entity.getProperty(fkPropName) === oldValue) {\r\n          entity.setProperty(fkPropName, newValue);\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  _fixupKey(tempValue: any, realValue: any) {\r\n    // single part keys appear directly in map\r\n    let ix = this._indexMap[tempValue];\r\n    if (ix === undefined) {\r\n      throw new Error(\"Internal Error in key fixup - unable to locate entity\");\r\n    }\r\n    let entity = this._entities[ix] as Entity;\r\n    let keyPropName = entity.entityType.keyProperties[0].name;\r\n    // fks on related entities will automatically get updated by this as well\r\n    entity.setProperty(keyPropName, realValue);\r\n    delete entity.entityAspect.hasTempKey;\r\n    delete this._indexMap[tempValue];\r\n    this._indexMap[realValue] = ix;\r\n  }\r\n\r\n  _replaceKey(oldKey: EntityKey, newKey: EntityKey) {\r\n    let ix = this._indexMap[oldKey._keyInGroup];\r\n    delete this._indexMap[oldKey._keyInGroup];\r\n    this._indexMap[newKey._keyInGroup] = ix;\r\n  }\r\n\r\n}\r\n\r\nfunction getFilter(entityStates: EntityState[]) {\r\n  if (entityStates.length === 0) {\r\n    return function (e: Entity) {\r\n      return !!e;\r\n    };\r\n  } else if (entityStates.length === 1) {\r\n    let entityState = entityStates[0];\r\n    return function (e: Entity) {\r\n      return !!e && e.entityAspect.entityState === entityState;\r\n    };\r\n  } else {\r\n    return function (e: Entity) {\r\n      return !!e && -1 !== entityStates.indexOf(e.entityAspect.entityState);\r\n    };\r\n  }\r\n}\r\n\r\n\r\n// do not expose EntityGroup - internal only\r\n\r\n\r\n"]}

package/esm2020/src/entity-key.mjs

@@ -0,0 +1,116 @@
+import { core } from './core';
+import { assertParam } from './assert-param';
+import { EntityType } from './entity-metadata';
+import { DataType } from './data-type';
+/**
+An EntityKey is an object that represents the unique identity of an entity.  EntityKey's are immutable.
+
+
+**/
+export class EntityKey {
+    /**
+    Constructs a new EntityKey.  Each entity within an EntityManager will have a unique EntityKey.
+    >     // assume em1 is an EntityManager containing a number of existing entities.
+    >     var empType = em1.metadataStore.getEntityType("Employee");
+    >     var entityKey = new EntityKey(empType, 1);
+  
+    EntityKey's may also be found by calling EntityAspect.getKey()
+    >     // assume employee1 is an existing Employee entity
+    >     var empKey = employee1.entityAspect.getKey();
+  
+    Multipart keys are created by passing an array as the 'keyValues' parameter
+    >     var empTerrType = em1.metadataStore.getEntityType("EmployeeTerritory");
+    >     var empTerrKey = new EntityKey(empTerrType, [ 1, 77]);
+    >     // The order of the properties in the 'keyValues' array must be the same as that
+    >     // returned by empTerrType.keyProperties
+    @param entityType - The [[EntityType]] of the entity.
+    @param keyValues - A single value or an array of values.
+    */
+    constructor(entityType, keyValues) {
+        assertParam(entityType, "entityType").isInstanceOf(EntityType).check();
+        let subtypes = entityType.getSelfAndSubtypes();
+        if (subtypes.length > 1) {
+            this._subtypes = subtypes.filter(function (st) {
+                return st.isAbstract === false;
+            });
+        }
+        if (!Array.isArray(keyValues)) {
+            keyValues = [keyValues];
+        }
+        this.entityType = entityType;
+        entityType.keyProperties.forEach(function (kp, i) {
+            // insure that guid keys are comparable.
+            if (kp.dataType === DataType.Guid) {
+                keyValues[i] = keyValues[i] && keyValues[i].toLowerCase ? keyValues[i].toLowerCase() : keyValues[i];
+            }
+        });
+        this.values = keyValues;
+        this._keyInGroup = EntityKey.createKeyString(keyValues);
+    }
+    toJSON() {
+        return {
+            entityType: this.entityType.name,
+            values: this.values
+        };
+    }
+    static fromJSON(json, metadataStore) {
+        let et = metadataStore._getStructuralType(json.entityType, true);
+        return new EntityKey(et, json.values);
+    }
+    /**
+    Used to compare EntityKeys are determine if they refer to the same Entity.
+    There is also an static version of 'equals' with the same functionality.
+    
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      var empType = em1.metadataStore.getEntityType("Employee");
+    >      var empKey1 = new EntityKey(empType, 1);
+    >      // assume employee1 is an existing Employee entity
+    >      var empKey2 = employee1.entityAspect.getKey();
+    >      if (empKey1.equals(empKey2)) {
+    >          // do something  ...
+    >      }
+    **/
+    equals(entityKey) {
+        if (!(entityKey instanceof EntityKey))
+            return false;
+        return (this.entityType === entityKey.entityType) &&
+            core.arrayEquals(this.values, entityKey.values);
+    }
+    /*
+    Returns a human readable representation of this EntityKey.
+    */
+    toString(altEntityType) {
+        return (altEntityType || this.entityType).name + '-' + this._keyInGroup;
+    }
+    /**
+    Used to compare EntityKeys are determine if they refer to the same Entity.
+    There is also an instance version of 'equals' with the same functionality.
+    >      // assume em1 is an EntityManager containing a number of existing entities.
+    >      var empType = em1.metadataStore.getEntityType("Employee");
+    >      var empKey1 = new EntityKey(empType, 1);
+    >      // assume employee1 is an existing Employee entity
+    >      var empKey2 = employee1.entityAspect.getKey();
+    >      if (EntityKey.equals(empKey1, empKey2)) {
+    >          // do something  ...
+    >      }
+    **/
+    static equals(k1, k2) {
+        if (!(k1 instanceof EntityKey))
+            return false;
+        return k1.equals(k2);
+    }
+    /** @hidden @internal */
+    // TODO: we may want to compare to default values later.
+    _isEmpty() {
+        return this.values.join("").length === 0;
+    }
+    /** hidden */
+    // TODO: think about giving _ prefix or documenting.
+    static createKeyString(keyValues) {
+        return keyValues.join(EntityKey.ENTITY_KEY_DELIMITER);
+    }
+}
+/** @hidden @internal */
+EntityKey.ENTITY_KEY_DELIMITER = ":::";
+EntityKey.prototype._$typeName = "EntityKey";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-key.js","sourceRoot":"","sources":["../../../src/entity-key.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { assertParam } from './assert-param';\r\nimport { EntityType, MetadataStore } from './entity-metadata';\r\nimport { DataType } from './data-type';\r\n\r\n/**\r\nAn EntityKey is an object that represents the unique identity of an entity.  EntityKey's are immutable.\r\n\r\n\r\n**/\r\nexport class EntityKey {\r\n  /** @hidden @internal */\r\n  _$typeName: string; // actually placed on prototype\r\n  /** @hidden @internal */\r\n  static ENTITY_KEY_DELIMITER = \":::\";\r\n  /**  The 'EntityType' that this is a key for. __Read Only__ */\r\n  entityType: EntityType;\r\n  /**  An array of the values for this key. This will usually only have a single element, \r\n  unless the entity type has a multipart key. __Read Only__ */\r\n  values: any[];\r\n  /** @hidden @internal */\r\n  _keyInGroup: string;\r\n  /** @hidden @internal */\r\n  _subtypes: EntityType[];\r\n\r\n  /**\r\n  Constructs a new EntityKey.  Each entity within an EntityManager will have a unique EntityKey.\r\n  >     // assume em1 is an EntityManager containing a number of existing entities.\r\n  >     var empType = em1.metadataStore.getEntityType(\"Employee\");\r\n  >     var entityKey = new EntityKey(empType, 1);\r\n\r\n  EntityKey's may also be found by calling EntityAspect.getKey()\r\n  >     // assume employee1 is an existing Employee entity\r\n  >     var empKey = employee1.entityAspect.getKey();\r\n\r\n  Multipart keys are created by passing an array as the 'keyValues' parameter\r\n  >     var empTerrType = em1.metadataStore.getEntityType(\"EmployeeTerritory\");\r\n  >     var empTerrKey = new EntityKey(empTerrType, [ 1, 77]);\r\n  >     // The order of the properties in the 'keyValues' array must be the same as that\r\n  >     // returned by empTerrType.keyProperties\r\n  @param entityType - The [[EntityType]] of the entity.\r\n  @param keyValues - A single value or an array of values. \r\n  */\r\n  constructor(entityType: EntityType, keyValues: any) {\r\n    assertParam(entityType, \"entityType\").isInstanceOf(EntityType).check();\r\n    let subtypes = entityType.getSelfAndSubtypes();\r\n    if (subtypes.length > 1) {\r\n      this._subtypes = subtypes.filter(function (st) {\r\n        return st.isAbstract === false;\r\n      });\r\n    }\r\n\r\n    if (!Array.isArray(keyValues)) {\r\n      keyValues = [keyValues];\r\n    }\r\n\r\n    this.entityType = entityType;\r\n    entityType.keyProperties.forEach(function (kp, i) {\r\n      // insure that guid keys are comparable.\r\n      if (kp.dataType === DataType.Guid) {\r\n        keyValues[i] = keyValues[i] && keyValues[i].toLowerCase ? keyValues[i].toLowerCase() : keyValues[i];\r\n      }\r\n    });\r\n\r\n    this.values = keyValues;\r\n    this._keyInGroup = EntityKey.createKeyString(keyValues);\r\n\r\n  }\r\n\r\n\r\n  toJSON() {\r\n    return {\r\n      entityType: this.entityType.name,\r\n      values: this.values\r\n    };\r\n  }\r\n\r\n  static fromJSON(json: any, metadataStore: MetadataStore) {\r\n    let et = metadataStore._getStructuralType(json.entityType, true) as EntityType;\r\n    return new EntityKey(et, json.values);\r\n  }\r\n\r\n  /**\r\n  Used to compare EntityKeys are determine if they refer to the same Entity.\r\n  There is also an static version of 'equals' with the same functionality.\r\n  \r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      var empType = em1.metadataStore.getEntityType(\"Employee\");\r\n  >      var empKey1 = new EntityKey(empType, 1);\r\n  >      // assume employee1 is an existing Employee entity\r\n  >      var empKey2 = employee1.entityAspect.getKey();\r\n  >      if (empKey1.equals(empKey2)) {\r\n  >          // do something  ...\r\n  >      }\r\n  **/\r\n  equals(entityKey: EntityKey): boolean {\r\n    if (!(entityKey instanceof EntityKey)) return false;\r\n    return (this.entityType === entityKey.entityType) &&\r\n      core.arrayEquals(this.values, entityKey.values);\r\n  }\r\n\r\n  /*\r\n  Returns a human readable representation of this EntityKey.\r\n  */\r\n  toString(altEntityType?: EntityType) {\r\n    return (altEntityType || this.entityType).name + '-' + this._keyInGroup;\r\n  }\r\n\r\n  /**\r\n  Used to compare EntityKeys are determine if they refer to the same Entity.\r\n  There is also an instance version of 'equals' with the same functionality.\r\n  >      // assume em1 is an EntityManager containing a number of existing entities.\r\n  >      var empType = em1.metadataStore.getEntityType(\"Employee\");\r\n  >      var empKey1 = new EntityKey(empType, 1);\r\n  >      // assume employee1 is an existing Employee entity\r\n  >      var empKey2 = employee1.entityAspect.getKey();\r\n  >      if (EntityKey.equals(empKey1, empKey2)) {\r\n  >          // do something  ...\r\n  >      }\r\n  **/\r\n  static equals(k1: EntityKey, k2: EntityKey) {\r\n    if (!(k1 instanceof EntityKey)) return false;\r\n    return k1.equals(k2);\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  // TODO: we may want to compare to default values later.\r\n  _isEmpty() {\r\n    return this.values.join(\"\").length === 0;\r\n  }\r\n\r\n  /** hidden */\r\n  // TODO: think about giving _ prefix or documenting.\r\n  static createKeyString(keyValues: any[]) {\r\n    return keyValues.join(EntityKey.ENTITY_KEY_DELIMITER);\r\n  }\r\n\r\n}\r\nEntityKey.prototype._$typeName = \"EntityKey\";\r\n\r\n\r\n"]}