TypeScript ListWrapper.insert方法代码示例

 // Misnomer: this method is attaching next to the view container.
 attachViewInContainer(parentView: viewModule.AppView, boundElementIndex: number,
                       contextView: viewModule.AppView, contextBoundElementIndex: number,
                       atIndex: number, view: viewModule.AppView) {
   if (isBlank(contextView)) {
     contextView = parentView;
     contextBoundElementIndex = boundElementIndex;
   }
   parentView.changeDetector.addChild(view.changeDetector);
   var viewContainer = this._getOrCreateViewContainer(parentView, boundElementIndex);
   ListWrapper.insert(viewContainer.views, atIndex, view);
   var sibling;
   if (atIndex == 0) {
     sibling = null;
   } else {
     sibling = ListWrapper.last(viewContainer.views[atIndex - 1].rootElementInjectors)
   }
   var elementInjector = contextView.elementInjectors[contextBoundElementIndex];
   for (var i = view.rootElementInjectors.length - 1; i >= 0; i--) {
     if (isPresent(elementInjector.parent)) {
       view.rootElementInjectors[i].linkAfter(elementInjector.parent, sibling);
     } else {
       contextView.rootElementInjectors.push(view.rootElementInjectors[i]);
     }
   }
 }

 .andCallFake((parentView, elementIndex, _a, _b, atIndex, childView) => {
   var viewContainer = parentView.viewContainers[elementIndex];
   if (isBlank(viewContainer)) {
     viewContainer = new AppViewContainer();
     parentView.viewContainers[elementIndex] = viewContainer;
   }
   ListWrapper.insert(viewContainer.views, atIndex, childView);
 });

 it('should support insertions/moves', () => {
   l = ['a', 'a', 'b', 'b'];
   changes.check(l);
   ListWrapper.insert(l, 0, 'b');
   changes.check(l);
   expect(changes.toString()).toEqual(iterableChangesAsString({
     collection: ['b[2->0]', 'a[0->1]', 'a[1->2]', 'b', 'b[null->4]'],
     previous: ['a[0->1]', 'a[1->2]', 'b[2->0]', 'b'],
     additions: ['b[null->4]'],
     moves: ['b[2->0]', 'a[0->1]', 'a[1->2]']
   }));
 });

 insert(view, atIndex = -1) {
   if (atIndex == -1)
     atIndex = this._views.length;
   ListWrapper.insert(this._views, atIndex, view);
   if (isBlank(this._lightDom)) {
     ViewContainer.moveViewNodesAfterSibling(this._siblingToInsertAfter(atIndex), view);
   } else {
     this._lightDom.redistribute();
   }
   this.parentView.changeDetector.addChild(view.changeDetector);
   this._linkElementInjectors(view);
   return view;
 }

 this._selectorMatcher.match(cssSelector, (selector, directiveIndex) => {
   elementBinder = current.bindElement();
   var directive = this._directives[directiveIndex];
   if (directive.type === DirectiveMetadata.COMPONENT_TYPE) {
     // components need to go first, so it is easier to locate them in the result.
     ListWrapper.insert(foundDirectiveIndices, 0, directiveIndex);
     if (isPresent(componentDirective)) {
       throw new BaseException(
           `Only one component directive is allowed per element - check ${current.elementDescription}`);
     }
     componentDirective = directive;
     elementBinder.setComponentId(directive.id);
   } else {
     ListWrapper.push(foundDirectiveIndices, directiveIndex);
   }
 });

 mergeChildComponentProtoViews(protoViews, target) {
   var elementBinders = ListWrapper.createFixedSize(this.elementBinders.length);
   for (var i = 0; i < this.elementBinders.length; i++) {
     var eb = this.elementBinders[i];
     if (isPresent(eb.componentId) || isPresent(eb.nestedProtoView)) {
       elementBinders[i] = eb.mergeChildComponentProtoViews(protoViews, target);
     } else {
       elementBinders[i] = eb;
     }
   }
   var result = new ProtoView({
     elementBinders: elementBinders,
     element: this.element,
     isRootView: this.isRootView
   });
   ListWrapper.insert(target, 0, result);
   return result;
 }

 insert(view, atIndex = -1) {
   this._checkHydrated();
   if (atIndex == -1)
     atIndex = this._views.length;
   ListWrapper.insert(this._views, atIndex, view);
   if (!view.hydrated()) {
     view.hydrate(this._hostLightDom);
   }
   if (isBlank(this._lightDom)) {
     ViewContainer.moveViewNodesAfterSibling(this._siblingToInsertAfter(atIndex), view);
   } else {
     this._lightDom.redistribute();
   }
   if (isPresent(this._hostLightDom)) {
     this._hostLightDom.redistribute();
   }
   return view;
 }