Register the given value via {@link MinMaxAvgProbe#register(long)} for the probe of the given {@link StatsType}.
@param statsType the specific execution type that is measured.
@param value the value to register.
423120
public void register( @Nonnull final StatsType statsType, final long value ) {
        _probes.get( statsType ).register( value );
    }
715404
public void setStat(double[] dataValue, int calibrationType, boolean[] calibrate) {
        this.data = dataValue;
        this.calibrationType = calibrationType;
        this.calibrationFlag = calibrate;

        calibrationDataSize = 0;
        for (int i = 0; i < this.calibrationFlag.length; i++) {
            if (calibrate[i]) {
                calibrationDataSize++;
            }
        }

        calculateMean();
        findMin();
        findMax();
//        setDeviation();
    }
897522
public void updateMetricFromRPC(Object value) {
        if (value == null) {
            incr();
        } else if (value instanceof Long) {
            incrBy((Long) value);
        } else {
            throw new RuntimeException("CountShellMetric updateMetricFromRPC params should be null or Long");
        }
    }
1324351
public final void registerExecutionType(ExecutionType executionType) {
	if (executionType == null) {
	  throw new TaskExeception(ExecutionType.class.getSimpleName() + " NULL");
	}
	this.executionType = executionType;
  }
1240146
public static void register(MetricsRegistry metricsRegistry) {
        checkNotNull(metricsRegistry, "metricsRegistry");

        Runtime runtime = Runtime.getRuntime();
        RuntimeMXBean mxBean = ManagementFactory.getRuntimeMXBean();

        metricsRegistry.register(runtime, "runtime.freeMemory", MANDATORY, Runtime::freeMemory);
        metricsRegistry.register(runtime, "runtime.totalMemory", MANDATORY, Runtime::totalMemory);
        metricsRegistry.register(runtime, "runtime.maxMemory", MANDATORY, Runtime::maxMemory);
        metricsRegistry.register(runtime, "runtime.usedMemory", MANDATORY,
                (LongProbeFunction<Runtime>) runtime1 -> runtime1.totalMemory() - runtime1.freeMemory()
        );
        metricsRegistry.register(runtime, "runtime.availableProcessors", MANDATORY, Runtime::availableProcessors);
        metricsRegistry.register(mxBean, "runtime.uptime", MANDATORY, RuntimeMXBean::getUptime);
    }
796687
public void put(Integer value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			compiledStatement.bindLong(compiledStatementBindIndex++, value);
		}
	}
71594
@Override
    public void registerStatsStorageListener(StatsStorageListener listener) {
        if (!this.listeners.contains(listener)) {
            this.listeners.add(listener);
        }
    }
947030
public void setCostType(com.google.api.ads.admanager.axis.v201902.CostType costType) {
        this.costType = costType;
    }
95235
@Nullable
    private <S> S runComputeStatistics(GraqlCompute.Statistics.Value query) {
        AttributeType.DataType<?> targetDataType = validateAndGetTargetDataType(query);
        if (!targetContainsInstance(query)) return null;

        Set<LabelId> extendedScopeTypes = convertLabelsToIds(extendedScopeTypeLabels(query));
        Set<LabelId> targetTypes = convertLabelsToIds(targetTypeLabels(query));

        VertexProgram program = initStatisticsVertexProgram(query, targetTypes, targetDataType);
        StatisticsMapReduce<?> mapReduce = initStatisticsMapReduce(query, targetTypes, targetDataType);
        ComputerResult computerResult = compute(program, mapReduce, extendedScopeTypes);

        if (query.method().equals(MEDIAN)) {
            Number result = computerResult.memory().get(MedianVertexProgram.MEDIAN);
            LOG.debug("Median = {}", result);
            return (S) result;
        }

        Map<Serializable, S> resultMap = computerResult.memory().get(mapReduce.getClass().getName());
        LOG.debug("Result = {}", resultMap.get(MapReduce.NullObject.instance()));
        return resultMap.get(MapReduce.NullObject.instance());
    }
1341131
@GwtIncompatible("incompatible method")
    private static void register(final Object value) {
        Set<IDKey> registry = getRegistry();
        if (registry == null) {
            registry = new HashSet<>();
            REGISTRY.set(registry);
        }
        registry.add(new IDKey(value));
    }
1574
protected TypeValuePairType getTypeValuePair(String type, byte[] value) {
        TypeValuePairType tvp = new TypeValuePairType();
        tvp.setType(type);
        //tvp.setValue(Base64.encodeBase64Chunked(value));
        // the TVP itself base64 encodes now, no need for this
        tvp.setValue(value);
        return tvp;
    }
476713
@VisibleForTesting
  static MetricDescriptor.ValueType createValueType(Type type) {
    if (type == Type.CUMULATIVE_DOUBLE || type == Type.GAUGE_DOUBLE) {
      return MetricDescriptor.ValueType.DOUBLE;
    } else if (type == Type.GAUGE_INT64 || type == Type.CUMULATIVE_INT64) {
      return MetricDescriptor.ValueType.INT64;
    } else if (type == Type.GAUGE_DISTRIBUTION || type == Type.CUMULATIVE_DISTRIBUTION) {
      return MetricDescriptor.ValueType.DISTRIBUTION;
    }
    return MetricDescriptor.ValueType.UNRECOGNIZED;
  }
444494
public boolean recordThrowType(JSTypeExpression type) {
    if (type != null && !hasAnySingletonTypeTags()) {
      currentInfo.declareThrows(type);
      populated = true;
      return true;
    }
    return false;
  }
907163
static Stat getStatsForType(String type) {
    Stat stat = getThreadTrace().stats.get(type);
    return stat != null ? stat : ZERO_STAT;
  }
160882
public static final boolean valueIsNotDefault(FieldType type, Object value)
   {
      boolean result = true;

      if (value == null)
      {
         result = false;
      }
      else
      {
         DataType dataType = type.getDataType();
         switch (dataType)
         {
            case BOOLEAN:
            {
               result = ((Boolean) value).booleanValue();
               break;
            }

            case CURRENCY:
            case NUMERIC:
            {
               result = !NumberHelper.equals(((Number) value).doubleValue(), 0.0, 0.00001);
               break;
            }

            case DURATION:
            {
               result = (((Duration) value).getDuration() != 0);
               break;
            }

            default:
            {
               break;
            }
         }
      }

      return result;
   }
345197
@Override
    public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
66027
public void setMaxValue(final double VALUE) {
        if (Status.RUNNING == timeline.getStatus()) { timeline.jumpTo(Duration.ONE); }
        if (null == maxValue) {
            if (VALUE < getMinValue()) { setMinValue(VALUE); }
            _maxValue = Helper.clamp(getMinValue(), Double.MAX_VALUE, VALUE);
            setRange(_maxValue - getMinValue());
            if (Double.compare(originalMaxValue, Double.MAX_VALUE) == 0) originalMaxValue = _maxValue;
            if (Double.compare(originalThreshold, getThreshold()) > 0) { setThreshold(Helper.clamp(getMinValue(), _maxValue, originalThreshold)); }

            if (!valueProperty().isBound()) Gauge.this.setValue(Helper.clamp(getMinValue(), getMaxValue(), Gauge.this.getValue()));
            updateFormatString();
            fireUpdateEvent(RECALC_EVENT);
        } else {
            maxValue.set(VALUE);
        }
    }