TypeScript di.bind函數代碼示例

 static createBindings(childTokens: any[]): Provider[] {
   return [
     bind(_CHILDREN)
         .toFactory((injector: Injector) => childTokens.map(token => injector.get(token)),
                    [Injector]),
     bind(MultiReporter).toFactory(children => new MultiReporter(children), [_CHILDREN])
   ];
 }

 static bindTo(childTokens: any[]): Provider[] {
   var res = [
     bind(_CHILDREN)
         .toFactory((injector: Injector) => childTokens.map(token => injector.get(token)),
                    [Injector]),
     bind(WebDriverExtension)
         .toFactory(
             (children: WebDriverExtension[], capabilities) => {
               var delegate;
               children.forEach(extension => {
                 if (extension.supports(capabilities)) {
                   delegate = extension;
                 }
               });
               if (isBlank(delegate)) {
                 throw new BaseException('Could not find a delegate for given capabilities!');
               }
               return delegate;
             },
             [_CHILDREN, Options.CAPABILITIES])
   ];
   return res;
 }

    var validSample = this._validator.validate(completeSample);
    var resultPromise = this._reporter.reportMeasureValues(measureValues);
    if (isPresent(validSample)) {
      resultPromise =
          resultPromise.then((_) => this._reporter.reportSample(completeSample, validSample))
    }
    return resultPromise.then((_) => new SampleState(completeSample, validSample));
  }
}

export class SampleState {
  constructor(public completeSample: any[], public validSample: any[]) {}
}

var _PROVIDERS = [
  bind(Sampler)
      .toFactory((driver, metric, reporter, validator, prepare, execute, now) => new Sampler({
                   driver: driver,
                   reporter: reporter,
                   validator: validator,
                   metric: metric,
                   // TODO(tbosch): DI right now does not support null/undefined objects
                   // Mostly because the cache would have to be initialized with a
                   // special null object, which is expensive.
                   prepare: prepare !== false ? prepare : null,
                   execute: execute,
                   now: now
                 }),
                 [
                   WebDriverAdapter,
                   Metric,

  _markName(index) { return `${_MARK_NAME_PREFIX}${index}`; }
}

var _MICRO_ITERATIONS_REGEX = /(.+)\*(\d+)$/g;

var _MAX_RETRY_COUNT = 20;
var _MARK_NAME_PREFIX = 'benchpress';
var _SET_TIMEOUT = new OpaqueToken('PerflogMetric.setTimeout');

var _MARK_NAME_FRAME_CAPUTRE = 'frameCapture';
// using 17ms as a somewhat looser threshold, instead of 16.6666ms
var _FRAME_TIME_SMOOTH_THRESHOLD = 17;

var _PROVIDERS = [
  bind(PerflogMetric)
      .toFactory(
          (driverExtension, setTimeout, microMetrics, forceGc, captureFrames, receivedData,
           requestCount) => new PerflogMetric(driverExtension, setTimeout, microMetrics, forceGc,
                                              captureFrames, receivedData, requestCount),
          [
            WebDriverExtension,
            _SET_TIMEOUT,
            Options.MICRO_METRICS,
            Options.FORCE_GC,
            Options.CAPTURE_FRAMES,
            Options.RECEIVED_DATA,
            Options.REQUEST_COUNT
          ]),
  provide(_SET_TIMEOUT, {useValue: (fn, millis) => TimerWrapper.setTimeout(fn, millis)})
];

    // The ios protocol does not support the notions of multiple processes in
    // the perflog...
    'pid': 'pid0'
  };
  if (isPresent(args)) {
    result['args'] = args;
  }
  return result;
}

function createStartEvent(name, time, args = null) {
  return createEvent('B', name, time, args);
}

function createEndEvent(name, time, args = null) {
  return createEvent('E', name, time, args);
}

function createMarkStartEvent(name, time) {
  return createEvent('b', name, time);
}

function createMarkEndEvent(name, time) {
  return createEvent('e', name, time);
}

var _PROVIDERS = [
  bind(IOsDriverExtension)
      .toFactory((driver) => new IOsDriverExtension(driver), [WebDriverAdapter])
];

 static bindTo(delegateToken): Provider[] {
   return [bind(Reporter).toFactory((delegate) => delegate, [delegateToken])];
 }

    this._printStringRow(this._metricNames.map(metricName => {
      var samples = validSamples.map(measureValues => measureValues.values[metricName]);
      var mean = Statistic.calculateMean(samples);
      var cv = Statistic.calculateCoefficientOfVariation(samples, mean);
      var formattedMean = ConsoleReporter._formatNum(mean)
                              // Note: Don't use the unicode character for +- as it might cause
                              // hickups for consoles...
                              return NumberWrapper.isNaN(cv) ?
                              formattedMean :
                              `${formattedMean}+-${Math.floor(cv)}%`;
    }));
    return PromiseWrapper.resolve(null);
  }

  _printStringRow(parts: any[], fill = ' ') {
    this._print(
        parts.map(part => ConsoleReporter._lpad(part, this._columnWidth, fill)).join(' | '));
  }
}

var _PRINT = new OpaqueToken('ConsoleReporter.print');
var _COLUMN_WIDTH = new OpaqueToken('ConsoleReporter.columnWidth');
var _PROVIDERS = [
  bind(ConsoleReporter)
      .toFactory((columnWidth, sampleDescription, print) =>
                     new ConsoleReporter(columnWidth, sampleDescription, print),
                 [_COLUMN_WIDTH, SampleDescription, _PRINT]),
  provide(_COLUMN_WIDTH, {useValue: 18}),
  provide(_PRINT, {useValue: print})
];

  static get PROVIDERS(): Provider[] { return _PROVIDERS; }
  description: {[key: string]: any};

  constructor(public id: string, descriptions: Array<{[key: string]: any}>,
              public metrics: {[key: string]: any}) {
    this.description = {};
    descriptions.forEach(description => {
      StringMapWrapper.forEach(description, (value, prop) => this.description[prop] = value);
    });
  }

  toJson() { return {'id': this.id, 'description': this.description, 'metrics': this.metrics}; }
}

var _PROVIDERS = [
  bind(SampleDescription)
      .toFactory((metric, id, forceGc, userAgent, validator, defaultDesc, userDesc) =>
                     new SampleDescription(id,
                                           [
                                             {'forceGc': forceGc, 'userAgent': userAgent},
                                             validator.describe(),
                                             defaultDesc,
                                             userDesc
                                           ],
                                           metric.describe()),
                 [
                   Metric,
                   Options.SAMPLE_ID,
                   Options.FORCE_GC,
                   Options.USER_AGENT,
                   Validator,

  validate(completeSample: MeasureValues[]): MeasureValues[] {
    if (completeSample.length >= this._sampleSize) {
      var latestSample = ListWrapper.slice(completeSample, completeSample.length - this._sampleSize,
                                           completeSample.length);
      var xValues = [];
      var yValues = [];
      for (var i = 0; i < latestSample.length; i++) {
        // For now, we only use the array index as x value.
        // TODO(tbosch): think about whether we should use time here instead
        xValues.push(i);
        yValues.push(latestSample[i].values[this._metric]);
      }
      var regressionSlope = Statistic.calculateRegressionSlope(
          xValues, Statistic.calculateMean(xValues), yValues, Statistic.calculateMean(yValues));
      return regressionSlope >= 0 ? latestSample : null;
    } else {
      return null;
    }
  }
}

var _SAMPLE_SIZE = new OpaqueToken('RegressionSlopeValidator.sampleSize');
var _METRIC = new OpaqueToken('RegressionSlopeValidator.metric');
var _PROVIDERS = [
  bind(RegressionSlopeValidator)
      .toFactory((sampleSize, metric) => new RegressionSlopeValidator(sampleSize, metric),
                 [_SAMPLE_SIZE, _METRIC]),
  provide(_SAMPLE_SIZE, {useValue: 10}),
  provide(_METRIC, {useValue: 'scriptTime'})
];

  static get CAPTURE_FRAMES() { return _CAPTURE_FRAMES; }
}

var _SAMPLE_ID = new OpaqueToken('Options.sampleId');
var _DEFAULT_DESCRIPTION = new OpaqueToken('Options.defaultDescription');
var _SAMPLE_DESCRIPTION = new OpaqueToken('Options.sampleDescription');
var _FORCE_GC = new OpaqueToken('Options.forceGc');
var _PREPARE = new OpaqueToken('Options.prepare');
var _EXECUTE = new OpaqueToken('Options.execute');
var _CAPABILITIES = new OpaqueToken('Options.capabilities');
var _USER_AGENT = new OpaqueToken('Options.userAgent');
var _MICRO_METRICS = new OpaqueToken('Options.microMetrics');
var _NOW = new OpaqueToken('Options.now');
var _WRITE_FILE = new OpaqueToken('Options.writeFile');
var _RECEIVED_DATA = new OpaqueToken('Options.receivedData');
var _REQUEST_COUNT = new OpaqueToken('Options.requestCount');
var _CAPTURE_FRAMES = new OpaqueToken('Options.frameCapture');

var _DEFAULT_PROVIDERS = [
  bind(_DEFAULT_DESCRIPTION)
      .toValue({}),
  provide(_SAMPLE_DESCRIPTION, {useValue: {}}),
  provide(_FORCE_GC, {useValue: false}),
  provide(_PREPARE, {useValue: false}),
  provide(_MICRO_METRICS, {useValue: {}}),
  provide(_NOW, {useValue: () => DateWrapper.now()}),
  provide(_RECEIVED_DATA, {useValue: false}),
  provide(_REQUEST_COUNT, {useValue: false}),
  provide(_CAPTURE_FRAMES, {useValue: false})
];