return (p0, p1) => { if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1)) { v0 = p0; v1 = p1; result = fn(p0, p1); } return result; };
return (p0, p1, p2) => { if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2)) { v0 = p0; v1 = p1; v2 = p2; result = fn(p0, p1, p2); } return result; };
return (p0, p1, p2, p3, p4) => { if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) || !looseIdentical(v3, p3) || !looseIdentical(v4, p4)) { v0 = p0; v1 = p1; v2 = p2; v3 = p3; v4 = p4; result = fn(p0, p1, p2, p3, p4); } return result; };
// todo(vicb): optim for UnmodifiableListView (frozen arrays) check(collection) { this._reset(); var record = this._itHead; var mayBeDirty = false; var index; var item; var itemTrackBy; if (isArray(collection)) { var list = collection; this._length = collection.length; for (index = 0; index < this._length; index++) { item = list[index]; itemTrackBy = this._trackByFn(index, item); if (record === null || !looseIdentical(record.trackById, itemTrackBy)) { record = this._mismatch(record, item, itemTrackBy, index); mayBeDirty = true; } else { if (mayBeDirty) { // TODO(misko): can we limit this to duplicates only? record = this._verifyReinsertion(record, item, itemTrackBy, index); } if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item); } record = record._next; } } else { index = 0; iterateListLike(collection, (item) => { itemTrackBy = this._trackByFn(index, item); if (record === null || !looseIdentical(record.trackById, itemTrackBy)) { record = this._mismatch(record, item, itemTrackBy, index); mayBeDirty = true; } else { if (mayBeDirty) { // TODO(misko): can we limit this to duplicates only? record = this._verifyReinsertion(record, item, itemTrackBy, index); } if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item); } record = record._next; index++; }); this._length = index; } this._truncate(record); this._collection = collection; return this.isDirty; }
return (p0) => { if (!looseIdentical(v0, p0)) { v0 = p0; result = fn(p0); } return result; };
SelectControlValueAccessor.prototype._getOptionId = function (value) { for (var _i = 0, _a = collection_1.MapWrapper.keys(this._optionMap); _i < _a.length; _i++) { var id = _a[_i]; if (lang_1.looseIdentical(this._optionMap.get(id), value)) return id; } return null; };
function isPropertyUpdated(changes, viewModel) { if (!collection_1.StringMapWrapper.contains(changes, "model")) return false; var change = changes["model"]; if (change.isFirstChange()) return true; return !lang_1.looseIdentical(viewModel, change.currentValue); }
iterateListLike(collection, (item) => { itemTrackBy = this._trackByFn(index, item); if (record === null || !looseIdentical(record.trackById, itemTrackBy)) { record = this._mismatch(record, item, itemTrackBy, index); mayBeDirty = true; } else { if (mayBeDirty) { // TODO(misko): can we limit this to duplicates only? record = this._verifyReinsertion(record, item, itemTrackBy, index); } if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item); } record = record._next; index++; });
export function arrayLooseIdentical(a, b) { if (a.length != b.length) return false; for (var i = 0; i < a.length; ++i) { if (!looseIdentical(a[i], b[i])) return false; } return true; }
// Returns a CollectionChangeRecord having CollectionChangeRecord.trackById == trackById and // CollectionChangeRecord.currentIndex >= afterIndex get(trackById, afterIndex) { var record; for (record = this._head; record !== null; record = record._nextDup) { if ((afterIndex === null || afterIndex < record.currentIndex) && looseIdentical(record.trackById, trackById)) { return record; } } return null; }
return (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9) => { if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) || !looseIdentical(v3, p3) || !looseIdentical(v4, p4) || !looseIdentical(v5, p5) || !looseIdentical(v6, p6) || !looseIdentical(v7, p7) || !looseIdentical(v8, p8) || !looseIdentical(v9, p9)) { v0 = p0; v1 = p1; v2 = p2; v3 = p3; v4 = p4; v5 = p5; v6 = p6; v7 = p7; v8 = p8; v9 = p9; result = fn(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); } return result; };
// Returns a CollectionChangeRecord having CollectionChangeRecord.item == item and // CollectionChangeRecord.currentIndex >= afterIndex get(item, afterIndex:int):CollectionChangeRecord { var record:CollectionChangeRecord; for (record = this._head; record !== null; record = record._nextDup) { if ((afterIndex === null || afterIndex < record.currentIndex) && looseIdentical(record.item, item)) { return record; } } return null; }
iterateListLike(collection, (item) => { if (record === null || !looseIdentical(record.item, item)) { record = this._mismatch(record, item, index); mayBeDirty = true; } else if (mayBeDirty) { // TODO(misko): can we limit this to duplicates only? record = this._verifyReinsertion(record, item, index); } record = record._next; index++ });
export function checkBinding(throwOnChange, oldValue, newValue) { if (throwOnChange) { if (!devModeEqual(oldValue, newValue)) { throw new ExpressionChangedAfterItHasBeenCheckedException(oldValue, newValue, null); } return false; } else { return !looseIdentical(oldValue, newValue); } }
/** * This is the core function which handles differences between collections. * * - `record` is the record which we saw at this position last time. If null then it is a new * item. * - `item` is the current item in the collection * - `index` is the position of the item in the collection * * @internal */ _mismatch(record, item, itemTrackBy, index) { // The previous record after which we will append the current one. var previousRecord; if (record === null) { previousRecord = this._itTail; } else { previousRecord = record._prev; // Remove the record from the collection since we know it does not match the item. this._remove(record); } // Attempt to see if we have seen the item before. record = this._linkedRecords === null ? null : this._linkedRecords.get(itemTrackBy, index); if (record !== null) { // We have seen this before, we need to move it forward in the collection. // But first we need to check if identity changed, so we can update in view if necessary if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item); this._moveAfter(record, previousRecord, index); } else { // Never seen it, check evicted list. record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(itemTrackBy); if (record !== null) { // It is an item which we have evicted earlier: reinsert it back into the list. // But first we need to check if identity changed, so we can update in view if necessary if (!looseIdentical(record.item, item)) this._addIdentityChange(record, item); this._reinsertAfter(record, previousRecord, index); } else { // It is a new item: add it. record = this._addAfter(new CollectionChangeRecord(item, itemTrackBy), previousRecord, index); } } return record; }
export function mapLooseIdentical(m1, m2) { var k1 = StringMapWrapper.keys(m1); var k2 = StringMapWrapper.keys(m2); if (k1.length != k2.length) { return false; } var key; for (var i = 0; i < k1.length; i++) { key = k1[i]; if (!looseIdentical(m1[key], m2[key])) { return false; } } return true; }
return (p0, p1, p2, p3, p4, p5, p6) => { if (!looseIdentical(v0, p0) || !looseIdentical(v1, p1) || !looseIdentical(v2, p2) || !looseIdentical(v3, p3) || !looseIdentical(v4, p4) || !looseIdentical(v5, p5) || !looseIdentical(v6, p6)) { v0 = p0; v1 = p1; v2 = p2; v3 = p3; v4 = p4; v5 = p5; v6 = p6; result = fn(p0, p1, p2, p3, p4, p5, p6); } return result; };
// todo(vicb): optim for UnmodifiableListView (frozen arrays) check(collection):boolean { this._reset(); var record:CollectionChangeRecord = this._itHead; var mayBeDirty:boolean = false; var index:int; var item; if (ListWrapper.isList(collection)) { var list = collection; this._length = collection.length; for (index = 0; index < this._length; index++) { item = list[index]; if (record === null || !looseIdentical(record.item, item)) { record = this._mismatch(record, item, index); mayBeDirty = true; } else if (mayBeDirty) { // TODO(misko): can we limit this to duplicates only? record = this._verifyReinsertion(record, item, index); } record = record._next; } } else { index = 0; iterateListLike(collection, (item) => { if (record === null || !looseIdentical(record.item, item)) { record = this._mismatch(record, item, index); mayBeDirty = true; } else if (mayBeDirty) { // TODO(misko): can we limit this to duplicates only? record = this._verifyReinsertion(record, item, index); } record = record._next; index++ }); this._length = index; } this._truncate(record); this._collection = collection; return this.isDirty; }
this._forEach(map, function (value, key) { var newSeqRecord; if (oldSeqRecord !== null && key === oldSeqRecord.key) { newSeqRecord = oldSeqRecord; if (!lang_1.looseIdentical(value, oldSeqRecord.currentValue)) { oldSeqRecord.previousValue = oldSeqRecord.currentValue; oldSeqRecord.currentValue = value; _this._addToChanges(oldSeqRecord); } } else { seqChanged = true; if (oldSeqRecord !== null) { oldSeqRecord._next = null; _this._removeFromSeq(lastOldSeqRecord, oldSeqRecord); _this._addToRemovals(oldSeqRecord); } if (records.has(key)) { newSeqRecord = records.get(key); } else { newSeqRecord = new KeyValueChangeRecord(key); records.set(key, newSeqRecord); newSeqRecord.currentValue = value; _this._addToAdditions(newSeqRecord); } } if (seqChanged) { if (_this._isInRemovals(newSeqRecord)) { _this._removeFromRemovals(newSeqRecord); } if (lastNewSeqRecord == null) { _this._mapHead = newSeqRecord; } else { lastNewSeqRecord._next = newSeqRecord; } } lastOldSeqRecord = oldSeqRecord; lastNewSeqRecord = newSeqRecord; oldSeqRecord = oldSeqRecord === null ? null : oldSeqRecord._next; });
this._forEach(map, (value, key) => { var newSeqRecord; if (oldSeqRecord !== null && key === oldSeqRecord.key) { newSeqRecord = oldSeqRecord; if (!looseIdentical(value, oldSeqRecord.currentValue)) { oldSeqRecord.previousValue = oldSeqRecord.currentValue; oldSeqRecord.currentValue = value; this._addToChanges(oldSeqRecord); } } else { seqChanged = true; if (oldSeqRecord !== null) { oldSeqRecord._next = null; this._removeFromSeq(lastOldSeqRecord, oldSeqRecord); this._addToRemovals(oldSeqRecord); } if (MapWrapper.contains(records, key)) { newSeqRecord = MapWrapper.get(records, key); } else { newSeqRecord = new KVChangeRecord(key); MapWrapper.set(records, key, newSeqRecord); newSeqRecord.currentValue = value; this._addToAdditions(newSeqRecord); } } if (seqChanged) { if (this._isInRemovals(newSeqRecord)) { this._removeFromRemovals(newSeqRecord); } if (lastNewSeqRecord == null) { this._mapHead = newSeqRecord; } else { lastNewSeqRecord._next = newSeqRecord; } } lastOldSeqRecord = oldSeqRecord; lastNewSeqRecord = newSeqRecord; oldSeqRecord = oldSeqRecord === null ? null : oldSeqRecord._next; });
ChangeDetectionUtil.looseNotIdentical = function (a, b) { return !lang_1.looseIdentical(a, b); };
toString():string { return looseIdentical(this.previousValue, this.currentValue) ? stringify(this.key) : (stringify(this.key) + '[' + stringify(this.previousValue) + '->' + stringify(this.currentValue) + ']'); }
// TODO(vicb): optimize excludedIdxs.indexOf (sorted array) rr => excludedIdxs.indexOf(rr.selfIndex) == -1 && rr.mode !== RecordType.DirectiveLifecycle && _haveSameDirIndex(rr, record) && rr.mode === record.mode && looseIdentical(rr.funcOrValue, record.funcOrValue) && rr.contextIndex === record.contextIndex && looseIdentical(rr.name, record.name) && ListWrapper.equals(rr.args, record.args));
static looseNotIdentical(a, b) { return !looseIdentical(a, b); }
// TODO(vicb): optimize excludedIdxs.indexOf (sorted array) function (rr) { return excludedIdxs.indexOf(rr.selfIndex) == -1 && rr.mode !== proto_record_1.RecordType.DirectiveLifecycle && _haveSameDirIndex(rr, record) && rr.mode === record.mode && lang_1.looseIdentical(rr.funcOrValue, record.funcOrValue) && rr.contextIndex === record.contextIndex && lang_1.looseIdentical(rr.name, record.name) && collection_1.ListWrapper.equals(rr.args, record.args); });
KeyValueChangeRecord.prototype.toString = function () { return lang_1.looseIdentical(this.previousValue, this.currentValue) ? lang_1.stringify(this.key) : (lang_1.stringify(this.key) + '[' + lang_1.stringify(this.previousValue) + '->' + lang_1.stringify(this.currentValue) + ']'); };