Set the maximum value

@param value The value to use as the upper bound
188737
public void setMax(int value) {
		updateDisable = true;
		maxSpinner.setValue(new Integer(value));
		updateDisable = false;
	}
822696
public void setMaxModificationsBeforeCommit(String value) {

        try {
            setMaxModificationsBeforeCommit(Integer.parseInt(value));
        } catch (Exception e) {
            LOG.error(
                Messages.get().getBundle().key(
                    Messages.LOG_PARSE_MAXCOMMIT_FAILED_2,
                    value,
                    new Integer(DEFAULT_MAX_MODIFICATIONS_BEFORE_COMMIT)),
                e);
            setMaxModificationsBeforeCommit(DEFAULT_MAX_MODIFICATIONS_BEFORE_COMMIT);
        }
    }
48942
def max(self, value):
        
        if value == self._defaults['max'] and 'max' in self._values:
            del self._values['max']
        else:
            self._values['max'] = value
293689
public void set(final T value) {
		if (this.value.compareAndSet(null, value)) {
			this.listeners.clear();
			this.cdl.countDown();
		}
	}
801445
def _set_max_value(self, max_value):
        """"""

        self._external_max_value = max_value

        # Check that the current value of the parameter is still within the boundaries. If not, issue a warning

        if self._external_max_value is not None and self.value > self._external_max_value:

            warnings.warn("The current value of the parameter %s (%s) "
                          "was above the new maximum %s." % (self.name, self.value, self._external_max_value),
                          exceptions.RuntimeWarning)
            self.value = self._external_max_value
1133970
public final void setMaxNumber(final int maxNumber) {
        Condition.INSTANCE.ensureGreater(maxNumber, getMinNumber(),
                "The maximum number must be greater than the minimum number");
        this.maxNumber = maxNumber;
        setNumber(Math.min(getNumber(), maxNumber));
    }
298312
public void setValue(final int VALUE) {
        value = VALUE < 0 ? 0 : (VALUE > 100 ? 100 : VALUE);
        init(getWidth(), getHeight());
        repaint(INNER_BOUNDS);
    }
108586
public void setMax(Double max) {
        String maxStr = doubleToNiceStr(max);
        JQMCommon.setAttribute(input, "max", maxStr);
        refreshMax(input.getElement().getId(), maxStr);
        validateValue();
    }
649590
public void setMax (float max) {
		if (min > max) throw new IllegalArgumentException("min can't be > max");

		this.max = max;

		if (current > max) {
			current = max;
			spinner.notifyValueChanged(spinner.isProgrammaticChangeEvents());
		}
	}
597349
public void setMax(int max) {
    if (max <= 0 || max < mProgress) {
      throw new IllegalArgumentException(
          String.format("Max (%d) must be > 0 and >= %d", max, mProgress));
    }
    mMax = max;
    invalidate();
  }
1041862
public LongParameter setMaximumValue(long maximumValue) {
		if (hasMinimumValue) {
			Util.checkParameter(maximumValue >= minimumValue,
				"Maximum value (" + maximumValue + ") must be greater than or equal to minimum (" + minimumValue + ")");
		}

		this.hasMaximumValue = true;
		this.maximumValue = maximumValue;

		return this;
	}
1141713
public final void setMaxValue(final int maxValue) {
        Condition.INSTANCE.ensureGreater(maxValue, getMinValue(),
                "The maximum value must be greater than the minimum value");
        this.maxValue = maxValue;
        setValue(Math.min(getValue(), maxValue));
    }
1223083
private void setMax(MtasRBTreeNode n) {
    n.max = n.right;
    if (n.leftChild != null) {
      n.max = Math.max(n.max, n.leftChild.max);
    }
    if (n.rightChild != null) {
      n.max = Math.max(n.max, n.rightChild.max);
    }
  }
62902
public void setMaxValue(final double MAX_VALUE) {
        // check min-max values
        if (Double.compare(MAX_VALUE, minValue) == 0) {
            throw new IllegalArgumentException("Max value cannot be equal to min value");
        }

        if (Double.compare(MAX_VALUE, minValue) < 0) {
            maxValue = minValue;
            minValue = MAX_VALUE;
        } else {
            maxValue = MAX_VALUE;
        }
        calculate();
        validate();
        calcAngleStep();
        fireStateChanged();
    }
981655
public void setAll(int value) {
        for (int i = 0; i < array.length; i++) {
            array[i] = value;
        }
    }
1335899
public void setStrength(int value) {
        int noStrength = options & ~STRENGTH_MASK;
        switch(value) {
        case Collator.PRIMARY:
        case Collator.SECONDARY:
        case Collator.TERTIARY:
        case Collator.QUATERNARY:
        case Collator.IDENTICAL:
            options = noStrength | (value << STRENGTH_SHIFT);
            break;
        default:
            throw new IllegalArgumentException("illegal strength value " + value);
        }
    }
273060
public void setSingleValue(final EndPoint<T> value) throws MIDDException {
        this.upperBound = this.lowerBound = new EndPoint<>(value);
        this.lowerBoundClosed = this.upperBoundClosed = true;

    }