TypeScript ListWrapper.createFixedSize方法代码示例

  constructor(private changeControlStrategy: string, private dispatcher: any,
              private pipeRegistry: PipeRegistry, private protos: List<ProtoRecord>,
              private directiveRecords: List<any>) {
    super();
    this.values = ListWrapper.createFixedSize(protos.length + 1);
    this.pipes = ListWrapper.createFixedSize(protos.length + 1);
    this.prevContexts = ListWrapper.createFixedSize(protos.length + 1);
    this.changes = ListWrapper.createFixedSize(protos.length + 1);

    ListWrapper.fill(this.values, uninitialized);
    ListWrapper.fill(this.pipes, null);
    ListWrapper.fill(this.prevContexts, uninitialized);
    ListWrapper.fill(this.changes, false);
    this.locals = null;
    this.directives = null;
  }

 _visitAll(asts: List<any>) {
   var res = ListWrapper.createFixedSize(asts.length);
   for (var i = 0; i < asts.length; ++i) {
     res[i] = asts[i].visit(this);
   }
   return res;
 }

export function main() {
  reflector.reflectionCapabilities = new ReflectionCapabilities();
  var size = getIntParameter('size');
  testList = ListWrapper.createFixedSize(size);

  bootstrap(AppComponent)
      .then((ref) => {
        var injector = ref.injector;
        var app: AppComponent = injector.get(AppComponent);
        var lifeCycle = injector.get(LifeCycle);

        bindAction('#reset', function() {
          app.reset();
          lifeCycle.tick();
        });

        // Baseline (plain components)
        bindAction('#createPlainComponents', function() {
          app.createPlainComponents();
          lifeCycle.tick();
        });

        // Components with decorators
        bindAction('#createComponentsWithDirectives', function() {
          app.createComponentsWithDirectives();
          lifeCycle.tick();
        });

        // Components with decorators
        bindAction('#createDynamicComponents', function() {
          app.createDynamicComponents();
          lifeCycle.tick();
        });
      });
}

 createAppProtoViews(hostComponentBinding: DirectiveBinding,
                     rootRenderProtoView: renderApi.ProtoViewDto,
                     allDirectives: List<DirectiveBinding>): List<AppProtoView> {
   var allRenderDirectiveMetadata =
       ListWrapper.map(allDirectives, directiveBinding => directiveBinding.metadata);
   var nestedPvsWithIndex = _collectNestedProtoViews(rootRenderProtoView);
   var nestedPvVariableBindings = _collectNestedProtoViewsVariableBindings(nestedPvsWithIndex);
   var nestedPvVariableNames =
       _collectNestedProtoViewsVariableNames(nestedPvsWithIndex, nestedPvVariableBindings);
   var changeDetectorDefs =
       _getChangeDetectorDefinitions(hostComponentBinding.metadata, nestedPvsWithIndex,
                                     nestedPvVariableNames, allRenderDirectiveMetadata);
   var protoChangeDetectors = ListWrapper.map(
       changeDetectorDefs,
       changeDetectorDef => this._changeDetection.createProtoChangeDetector(changeDetectorDef));
   var appProtoViews = ListWrapper.createFixedSize(nestedPvsWithIndex.length);
   ListWrapper.forEach(nestedPvsWithIndex, (pvWithIndex) => {
     var appProtoView =
         _createAppProtoView(pvWithIndex.renderProtoView, protoChangeDetectors[pvWithIndex.index],
                             nestedPvVariableBindings[pvWithIndex.index], allDirectives);
     if (isPresent(pvWithIndex.parentIndex)) {
       var parentView = appProtoViews[pvWithIndex.parentIndex];
       parentView.elementBinders[pvWithIndex.boundElementIndex].nestedProtoView = appProtoView;
     }
     appProtoViews[pvWithIndex.index] = appProtoView;
   });
   return appProtoViews;
 }

export function main() {
  var size = getIntParameter('size');
  testList = ListWrapper.createFixedSize(size);

  bootstrap(AppComponent)
      .then((ref) => {
        var injector = ref.injector;
        var app: AppComponent = ref.hostComponent;
        var appRef = injector.get(ApplicationRef);

        bindAction('#reset', function() {
          app.reset();
          appRef.tick();
        });

        // Baseline (plain components)
        bindAction('#createPlainComponents', function() {
          app.createPlainComponents();
          appRef.tick();
        });

        // Components with decorators
        bindAction('#createComponentsWithDirectives', function() {
          app.createComponentsWithDirectives();
          appRef.tick();
        });

        // Components with decorators
        bindAction('#createDynamicComponents', function() {
          app.createDynamicComponents();
          appRef.tick();
        });
      });
}

 _readArgs(proto: ProtoRecord) {
   var res = ListWrapper.createFixedSize(proto.args.length);
   var args = proto.args;
   for (var i = 0; i < args.length; ++i) {
     res[i] = this.values[args[i]];
   }
   return res;
 }

 function createView(pv = null, renderViewRef = null) {
   if (isBlank(pv)) {
     pv = createProtoView();
   }
   if (isBlank(renderViewRef)) {
     renderViewRef = new RenderViewRef();
   }
   var view = new AppView(renderer, pv, MapWrapper.create());
   view.render = renderViewRef;
   var elementInjectors = ListWrapper.createFixedSize(pv.elementBinders.length);
   for (var i = 0; i < pv.elementBinders.length; i++) {
     elementInjectors[i] = createElementInjector();
   }
   view.init(null, elementInjectors, [], ListWrapper.createFixedSize(pv.elementBinders.length),
             ListWrapper.createFixedSize(pv.elementBinders.length));
   return view;
 }

 childNodesAsList(el): List<any> {
   var childNodes = el.childNodes;
   var res = ListWrapper.createFixedSize(childNodes.length);
   for (var i = 0; i < childNodes.length; i++) {
     res[i] = childNodes[i];
   }
   return res;
 }

 constructor(private records: List<ProtoRecord>, private directiveRecords: List<any>,
             private utilName: string) {
   this._sanitizedNames = ListWrapper.createFixedSize(this.records.length + 1);
   this._sanitizedNames[CONTEXT_INDEX] = _CONTEXT_ACCESSOR;
   for (var i = 0, iLen = this.records.length; i < iLen; ++i) {
     this._sanitizedNames[i + 1] = sanitizeName(`${this.records[i].name}${i}`);
   }
 }

 constructor(changeControlStrategy, dispatcher, pipeRegistry, protoRecords, directiveMementos) {
   super();
   this.dispatcher = dispatcher;
   this.pipeRegistry = pipeRegistry;
   this.values = ListWrapper.createFixedSize(protoRecords.length + 1);
   this.pipes = ListWrapper.createFixedSize(protoRecords.length + 1);
   this.prevContexts = ListWrapper.createFixedSize(protoRecords.length + 1);
   this.changes = ListWrapper.createFixedSize(protoRecords.length + 1);
   ListWrapper.fill(this.values, uninitialized);
   ListWrapper.fill(this.pipes, null);
   ListWrapper.fill(this.prevContexts, uninitialized);
   ListWrapper.fill(this.changes, false);
   this.locals = null;
   this.protos = protoRecords;
   this.directiveMementos = directiveMementos;
   this.changeControlStrategy = changeControlStrategy;
 }