Set the detector threshold (min severity to report a warning).

@param threshold
the detector threshold
437962
public void setUserDetectorThreshold(int threshold) {
        String minPriority = ProjectFilterSettings.getIntPriorityAsString(threshold);
        filterSettings.setMinPriority(minPriority);
    }
671929
public void setWarnings(java.util.Collection<Warning> warnings) {
        if (warnings == null) {
            this.warnings = null;
            return;
        }

        this.warnings = new java.util.ArrayList<Warning>(warnings);
    }
1106476
private double checkThreshold(int value) {
    double threshold = (double) value;
    try {
      if (threshold < 0 || threshold > 100) {
        throw new NumberFormatException();
      }
      LOG.info("Using a threshold of " + threshold);
    } catch (NumberFormatException e) {
      System.err.println("Expect a double parameter in the range of [0, 100]: "
          + value);
      throw e;
    }
    return threshold;
  }
478276
@Override
    public void setParameters(Object[] params) throws CDKException {
        if (params.length > 1) {
            throw new CDKException("SigmaElectronegativityDescriptor only expects one parameter");
        }
        if (!(params[0] instanceof Integer)) {
            throw new CDKException("The parameter must be of type Integer");
        }
        if (params.length == 0) return;
        maxIterations = (Integer) params[0];
    }
518323
@Override
    public void setEnabled(boolean enabled) {
        if (this.enabled != enabled) {
            this.enabled = enabled;
            setProperty("enabled", Boolean.toString(enabled));
            if (enabled && getAlertThreshold() == AlertThreshold.OFF) {
                setAlertThreshold(AlertThreshold.DEFAULT);
            }
        }
    }
1179443
private void setProgressBarValue(int value, int maximum) {

    this.progressBar.setIndeterminate(false);

    if (this.progressBar.getMaximum() != maximum) {
      this.progressBar.setMaximum(maximum);
    }

    this.progressBar.setValue(value);

  }
179307
public void setEnabledValue(boolean e) {
		if (enablement) {
			enabled.setSelected(e);
		}
		minSpinner.setEnabled(enabled.isSelected() || !enablement);
		maxSpinner.setEnabled(enabled.isSelected() || !enablement);
	}
293689
public void set(final T value) {
		if (this.value.compareAndSet(null, value)) {
			this.listeners.clear();
			this.cdl.countDown();
		}
	}
428236
public void setMinMax(double min, double max)
    {
        if(min <= 0 || Double.isNaN(min) || Double.isInfinite(min))
            throw new IllegalArgumentException("min value must be positive, not " + min);
        else if(min >= max || Double.isNaN(max) || Double.isInfinite(max))
            throw new IllegalArgumentException("max (" + max + ") must be larger than min (" + min+")" );
        this.max = max;
        this.min = min;
        this.logMax = Math.log(max);
        this.logMin = Math.log(min);
        this.logDiff = logMax-logMin;
        this.diff = max-min;
    }
365117
def set_scanner_threshold(zap_helper, scanners, threshold):
    """"""
    if not scanners or 'all' in scanners:
        scanners = _get_all_scanner_ids(zap_helper)

    with zap_error_handler():
        zap_helper.set_scanner_alert_threshold(scanners, threshold)

    console.info('Set alert threshold to {0}.'.format(threshold))
6135
public void setThreshold(final Level level) {
        Level oldValue = this.thresholdLevel;
        thresholdLevel = level;
        firePropertyChange("threshold", oldValue, this.thresholdLevel);
    }
731677
public void warn(Object message, Throwable exception) {
    log(Level.WARN, message, exception);
  }
173289
public void warn(Object message, Throwable t) {
        doLog(Level.WARN, FQCN, message, null, t);
    }
1297718
public void setLimit(int limit) {
        FailureInterpreter fi = getFailureInterpreter();
        if (!(fi instanceof DefaultFailureInterpreter)) {
            throw new IllegalStateException("setLimit() not supported: this CircuitBreaker's FailureInterpreter isn't a DefaultFailureInterpreter.");
        }
        ((DefaultFailureInterpreter)fi).setLimit(limit);
    }
623726
def threshold(self):
        """"""
        if self._threshold is None:
            self._threshold = {
                'error': self.timer_warning,
                'warning': self.timer_ok,
            }[self.timer_fail]
        return self._threshold
686296
public void setLevel(@NonNull LogLevel level) {
        if (level == null) { throw new IllegalArgumentException("level cannot be null."); }

        if (logLevel == level) { return; }

        logLevel = level;
        setCallbackLevel(level);
    }
1290049
public void warn(Object message, Throwable exception) {
        log(Level.WARNING, String.valueOf(message), exception);
    }