Constructs a performance statistics instance. This is performed internally by the {@link WorldWindow}.
Applications do not construct instances of this class.
@alias FrameStatistics
@constructor
@classdesc Captures performance statistics.
166901
function () {

            // Internal: intentionally not documented
            this.frameCount = 0;

            // Internal: intentionally not documented
            this.frameTimeCumulative = 0;

            // Internal: intentionally not documented
            this.frameTimeBase = 0;

            // Internal: intentionally not documented
            this.frameTimeExtremes = [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];

            /**
             * The number of milliseconds required to render the most recent frame.
             * @type {Number}
             */
            this.frameTime = 0;

            /**
             * The number of milliseconds spent tessellating the terrain during the most recent frame.
             * @type {Number}
             */
            this.tessellationTime = 0;

            /**
             * The number of milliseconds spent rendering the active layers during the most recent frame.
             * @type {Number}
             */
            this.layerRenderingTime = 0;

            /**
             * The number of milliseconds spent rendering ordered renderables during the most recent frame.
             * @type {Number}
             */
            this.orderedRenderingTime = 0;

            /**
             * The number of terrain tiles in the most recent frame.
             * @type {Number}
             */
            this.terrainTileCount = 0;

            /**
             * The number of image tiles in the most recent frame.
             * @type {Number}
             */
            this.imageTileCount = 0;

            /**
             * The number of terrain tile renderings. Since terrain tiles are generally rendered more than once per
             * frame, this count will be greater than the number of terrain tiles created for the frame.
             * @type {Number}
             */
            this.renderedTileCount = 0;

            /**
             * The number of calls to [Tile.update()]{@link Tile#update} during the most recent frame.
             * @type {Number}
             */
            this.tileUpdateCount = 0;

            /**
             * The number of texture bind calls during the most recent frame.
             * @type {Number}
             */
            this.textureLoadCount = 0;

            /**
             * The number of WebGL VBO loads during the most recent frame.
             * @type {Number}
             */
            this.vboLoadCount = 0;

            /**
             * The average frame time over the most recent two seconds.
             * @type {Number}
             */
            this.frameTimeAverage = 0;

            /**
             * The average frame rate over the most recent two seconds.
             * @type {Number}
             */
            this.frameRateAverage = 0;

            /**
             * The minimum frame time over the most recent two seconds.
             * @type {Number}
             */
            this.frameTimeMin = 0;

            /**
             * The maximum frame time over the most recent two seconds.
             * @type {Number}
             */
            this.frameTimeMax = 0;
        }
315119
private Stat createStat(final WComponent comp) {
		Stat stat = new Stat();

		stat.setClassName(comp.getClass().getName());

		stat.setName(comp.getId());
		if (stat.getName() == null) {
			stat.setName("Unknown");
		}

		if (comp instanceof AbstractWComponent) {
			Object obj = AbstractWComponent.replaceWComponent((AbstractWComponent) comp);

			if (obj instanceof AbstractWComponent.WComponentRef) {
				stat.setRef(obj.toString());
			}
		}

		ComponentModel model = (ComponentModel) uic.getModel(comp);

		stat.setModelState(Stat.MDL_NONE);

		if (model != null) {
			if (comp.isDefaultState()) {
				stat.setModelState(Stat.MDL_DEFAULT);
			} else {
				addSerializationStat(model, stat);
			}
		}

		return stat;
	}
816466
function build() {
    // Start creating the body of the new Type constructor, first calling super()
    var _ret = buildIdentity.call(this);
    var typeId = _ret.typeId;
    var typeName = _ret.typeName;
    var body =
        '\tvar opts = options ? options : {};\n' +
        '\tthis.constructor.util._extend(this, opts.props);\n' +
        '\tthis.constructor.super_.call(this, opts.buffer, opts.offset' +
        (typeId ? '' : ', true') +
        ');\n';
    // Init fields
    body += _ret.body;
    body += buildSerialize.call(this);
    body += buildDeserialize.call(this);
    // Add to body all the read/write methods
    for (var i = 0; i < this._methods.length; i++) {
        body += this._methods[i];
    }
    if (logger.isDebugEnabled()) {
        logger.debug('Body for %s type constructor:', typeName);
        logger.debug('\n' + body);
    }
    return createConstructor(body, typeId, typeName);
}
1027223
public static StatsInstanceImpl createGroupInstance(String name, StatsGroup igroup, ObjectName userProvidedMBeanObjectName, boolean bCreateDefaultMBean,
                                                        StatisticActions actionLsnr)
                    throws StatsFactoryException {
        StatsGroupImpl group = (StatsGroupImpl) igroup;

        // construct path
        String[] parentPath = group.getPath();
        String[] path = new String[parentPath.length + 1];

        for (int i = 0; i < parentPath.length; i++) {
            path[i] = parentPath[i];
        }
        path[parentPath.length] = name;

        StatsInstanceImpl instance = new StatsInstanceImpl(name, group.getModuleConfig(), path, actionLsnr);
        //instance._scListener = scl;

        instance._register(userProvidedMBeanObjectName, bCreateDefaultMBean);

        return instance;
    }
681259
function _runInActiveDataframes (viewportExpressions, renderLayer) {
    const dataframes = renderLayer.getActiveDataframes();
    const inViewportFeaturesIDs = _runInDataframes(viewportExpressions, renderLayer, dataframes);

    _runImprovedForPartialFeatures(viewportExpressions, renderLayer, inViewportFeaturesIDs);
}
824418
public void analyseWC(final WComponent comp) {
		if (comp == null) {
			return;
		}

		statsByWCTree.put(comp, createWCTreeStats(comp));
	}
435127
static void constructAvgHitsGraph(Map.Entry<String, LrProjectScenarioResults> scenarioResults,
                                      JSONObject scenarioGraphData) {
        Map<Integer, WholeRunResult> avgHitsPerSec = scenarioResults.getValue().getAverageHitsPerSecondResults();
        JSONObject avgHitsPerSecGraphSet = extractWholeRunSlaResult(avgHitsPerSec, "Hits/Sec");
        if (!avgHitsPerSecGraphSet.getJSONArray(LABELS).isEmpty()) {
            avgHitsPerSecGraphSet.put(TITLE, "Average Hits per Second");
            avgHitsPerSecGraphSet.put(X_AXIS_TITLE, "Build number");
            avgHitsPerSecGraphSet.put(Y_AXIS_TITLE, "Hits");
            avgHitsPerSecGraphSet.put(DESCRIPTION,
                    "Displays the number of hits made on the Web server by Vusers " +
                            "during each second of the load test. This graph helps you evaluate the amount of load " +
                            "Vusers" +
                            " " +
                            "generate, in terms of the number of hits.");
            scenarioGraphData.put("avgHitsPerSec", avgHitsPerSecGraphSet);
        }
    }
358533
function (frameData) {
      // Would be better to check controller.streaming() in showOverlay, but that method doesn't exist, yet.
      this.setGraphic('wave');
      if (frameData.hands.length > 0) {
        this.recording.addFrame(frameData);
        this.hideOverlay();
      } else if ( !this.recording.blank() ) {
        this.finishRecording();
      }
    }
1146981
function buildChart() {
      var self = this;

      // If dataTable isn't set, build it
      var dataTable = _.isEmpty(self.dataTable) ? self.buildDataTable() : self.dataTable;

      self.wrapper = self.buildWrapper(self.chartType, dataTable, self.options, self.chartId);

      // Set the datatable on this instance
      self.dataTable = self.wrapper.getDataTable();

      // After chart is built, set it on this instance and resolve the promise.
      google.visualization.events.addOneTimeListener(self.wrapper, 'ready', function () {
        self.chart = self.wrapper.getChart();
        chartDeferred.resolve();
      });
    }
301385
View build() throws IOException {
        final Class<? extends T> proxyClass = generateProxyClass();
        if (proxyClass == null) {
            return null;
        }

        final Constructor<? extends T> constructor = getProxyClassConstructor(proxyClass);

        final View result;
        try {
            result = constructor.newInstance(CONSTRUCTOR_ARG_VALUES);
        } catch (InstantiationException e) {
            // Should not be thrown, generated class is not abstract.
            throw new AssertionError(e);
        } catch (IllegalAccessException e) {
            // Should not be thrown, the generated constructor is accessible.
            throw new AssertionError(e);
        } catch (InvocationTargetException e) {
            // Thrown when the base class constructor throws an exception.
            throw launderCause(e);
        }

        ((ViewProxy) result).setInterceptor(mInterceptor);
        return result;
    }
433232
private void initIFrames() {
    String i = "<iframe class=ibench id=%ID%bench src=html/%ID%bench.html></iframe>";
    if (! shareIframes ) {
      $(i.replaceAll("%ID%", "gwt")).appendTo(document).hide();
      for (Benchmark b : benchmarks) {
        if (b instanceof IframeBenchmark) {
          $(i.replaceAll("%ID%", b.getId())).appendTo(document).hide();
        }
      }
    } else {
      $(i.replaceAll("%ID%", "iframe")).appendTo(document).hide();
    }
  }
150360
private KeyFrame createSmallerScaleFrame(double errorContainerHeight) {
        return new KeyFrame(Duration.millis(100),
            new KeyValue(errorClipScale.yProperty(),
                errorContainerHeight / getHeight(),
                Interpolator.EASE_BOTH));
    }
110931
function AnimationFrame(options) {
    if (!(this instanceof AnimationFrame)) return new AnimationFrame(options)
    options || (options = {})

    // Its a frame rate.
    if (typeof options == 'number') options = {frameRate: options}
    options.useNative != null || (options.useNative = true)
    this.options = options
    this.frameRate = options.frameRate || AnimationFrame.FRAME_RATE
    this._frameLength = 1000 / this.frameRate
    this._isCustomFrameRate = this.frameRate !== AnimationFrame.FRAME_RATE
    this._timeoutId = null
    this._callbacks = {}
    this._lastTickTime = 0
    this._tickCounter = 0
}
66767
static void constructErrorGraph(Map.Entry<String, LrProjectScenarioResults> scenarioResults,
                                    JSONObject scenarioGraphData) {
        Map<Integer, TimeRangeResult> errPerSecResults = scenarioResults.getValue().getErrPerSecResults();
        JSONObject errPerSecResultsResultsGraphSet =
                extractTimeRangeResult(errPerSecResults);
        if (!errPerSecResultsResultsGraphSet.getJSONArray(LABELS).isEmpty()) {
            errPerSecResultsResultsGraphSet.put(TITLE, "Total errors per second");
            errPerSecResultsResultsGraphSet.put(X_AXIS_TITLE, "Build number");
            errPerSecResultsResultsGraphSet.put(Y_AXIS_TITLE, "Errors");
            errPerSecResultsResultsGraphSet.put(DESCRIPTION, "");
            scenarioGraphData.put("errorPerSecResults", errPerSecResultsResultsGraphSet);
        }
    }
1364617
function _runInDataframe (viz, viewportExpressions, dataframe, processedFeaturesIDs, inViewportFeaturesIDs) {
    for (let i = 0; i < dataframe.numFeatures; i++) {
        const idProperty = viz.metadata.idProperty;
        const featureId = dataframe.properties[idProperty][i];

        const featureAlreadyAccumulated = processedFeaturesIDs.has(featureId);
        if (featureAlreadyAccumulated) {
            continue; // This is correct for viewportExpressions related to 'alphanumeric' properties (not geometry-related)
        }

        const featureOutsideViewport = !dataframe.inViewport(i);
        if (featureOutsideViewport) {
            continue;
        }

        // a new feature, inside the viewport
        processedFeaturesIDs.add(featureId);
        const feature = dataframe.getFeature(i);

        const featureIsFilteredOut = viz.filter.eval(feature) < FILTERING_THRESHOLD;
        if (featureIsFilteredOut) {
            continue;
        }

        inViewportFeaturesIDs.add(feature[idProperty]); // inViewport & in filter

        // not a filtered feature, so pass the rawFeature to viewport expressions
        viewportExpressions.forEach(expr => expr.accumViewportAgg(feature));
    }
}
368891
function _runInDataframes (viewportExpressions, renderLayer, dataframes) {
    const processedFeaturesIDs = new Set(); // same feature can belong to multiple dataframes
    const viz = renderLayer.viz;

    const inViewportFeaturesIDs = new Set();
    dataframes.forEach(dataframe => {
        _runInDataframe(viz, viewportExpressions, dataframe, processedFeaturesIDs, inViewportFeaturesIDs);
    });
    return inViewportFeaturesIDs;
}
274157
function frame() {
      if (!frameRunning) {
        frameRunning = true;
        requestAnimationFrame(animationLoop);
      }
      return create.apply(qframe, arguments);
    }