Parses the alert options.

@see #getMaximumInstances()
185326
@Override
    protected void parse() {
        maximumInstances = getInt(PARAM_MAXIMUM_INSTANCES, DEFAULT_MAXIMUM_INSTANCES);
        mergeRelatedIssues = getBoolean(PARAM_MERGE_RELATED_ISSUES, true);
        overridesFilename = getString(PARAM_OVERRIDES_FILENAME, "");
    }
1004447
@Pure
	public IntegerProperty maxXProperty() {
		if (this.maxX == null) {
			this.maxX = new SimpleIntegerProperty(this, MathFXAttributeNames.MAXIMUM_X) {
				@Override
				protected void invalidated() {
					final int currentMax = get();
					final int currentMin = getMinX();
					if (currentMax < currentMin) {
						// min-max constrain is broken
						minXProperty().set(currentMax);
					}
				}
			};
		}
		return this.maxX;
	}
62654
public int getMaximumDigits() {
        String value = Optional.fromNullable(getParameter(SignalParameters.MAXIMUM_NUM_DIGITS.symbol())).or("1");
        return Integer.parseInt(value);
    }
652455
private void calculateHighestAlert() {
        synchronized (alerts) {
            highestAlert = null;
            for (Alert alert : alerts) {
                if (isHighestAlert(alert)) {
                    highestAlert = alert;
                }
            }
            calculateHighestAlert = false;
        }
    }
693224
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
  public CallOptions withMaxInboundMessageSize(int maxSize) {
    checkArgument(maxSize >= 0, "invalid maxsize %s", maxSize);
    CallOptions newOptions = new CallOptions(this);
    newOptions.maxInboundMessageSize = maxSize;
    return newOptions;
  }
265507
private int getMaximum() {
		int max = 0;
		for (int x = 0; x <= T.length - 1; x++) {
			if (T[x] > max) max = T[x];
			if (A[x] > max) max = A[x];
			if (C[x] > max) max = C[x];
			if (G[x] > max) max = G[x];
		}
		return max;
	}
274923
private void parseMaxPersist(Map<Object, Object> props) {
        // -1 means unlimited
        // 0..1 means 1
        // X means X
        Object value = props.get(HttpConfigConstants.PROPNAME_MAX_PERSIST);
        if (null != value) {
            try {
                this.maxPersistRequest = minLimit(convertInteger(value), HttpConfigConstants.MIN_PERSIST_REQ);
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                    Tr.event(tc, "Config: Max persistent requests is " + getMaximumPersistentRequests());
                }
            } catch (NumberFormatException nfe) {
                FFDCFilter.processException(nfe, getClass().getName() + ".parseMaxPersist", "1");
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                    Tr.event(tc, "Config: Invalid max persistent requests; " + value);
                }
            }
        }
    }
564487
public static void checkMinMax(int min, int max) {
    checkMin(min);
    checkMax(max);
    checkArgument(min <= max, "min > max");
  }
449857
public static double[] getMaximumValues(Front front) {
    if (front == null) {
      throw new NullFrontException() ;
    } else if (front.getNumberOfPoints() == 0) {
      throw new EmptyFrontException() ;
    }

    int numberOfObjectives = front.getPoint(0).getDimension() ;

    double[] maximumValue = new double[numberOfObjectives];
    for (int i = 0; i < numberOfObjectives; i++) {
      maximumValue[i] = Double.NEGATIVE_INFINITY;
    }

    for (int i = 0 ; i < front.getNumberOfPoints(); i++) {
      for (int j = 0; j < numberOfObjectives; j++) {
        if (front.getPoint(i).getValue(j) > maximumValue[j]) {
          maximumValue[j] = front.getPoint(i).getValue(j);
        }
      }
    }

    return maximumValue;
  }
30578
public T getMaximum() {
        Lock lock = this.lock.readLock();
        lock.lock();
        try {
            return this.maximum;
        } finally {
            lock.unlock();
        }
    }
125691
private void setCalculateHighestAlertIfSameAlert(Alert alert) {
        if (highestAlert != null && highestAlert.getAlertId() == alert.getAlertId()) {
            calculateHighestAlert = true;
            highestAlert = null;
        }
    }
396787
@Override
    public long getMaxX() {
        if (!excludeOutOfRangeValues) {
            return super.getMaxX();
        } else {
            long retMax = 0;
            Iterator<Long> iter = values.keySet().iterator();

            if (iter.hasNext()) {
                retMax = iter.next();
            }
            long excludeValue = getGranulationValue() * excludeCount;
            while (iter.hasNext()) {
                long value = iter.next();

                if (value > retMax) {
                    if ((value - retMax) < excludeValue) {
                        retMax = value;
                    }
                }
            }
            return retMax;
        }
    }
667126
private function getInstancesMaxAllowedDeclaration()
    {

        if( !$this->isMultiton() or !array_key_exists( 'instancesMaxAllowed', $this->entity->normalityTags ) ) {
            return array();
        }

        $instancesMaxAllowed = is_numeric( $this->entity->normalityTags['instancesMaxAllowed'] )
            ? (int) $this->entity->normalityTags['instancesMaxAllowed']
            : null
            ;

        $instancesMaxAllowed = Php::varExport( $instancesMaxAllowed, true );

        $this->class->classComponents[] = new VariableDeclaration(
            'instancesMaxAllowed',
            new SFormatf( <<<'PHP'
                /**
                 * Max number of instances stored by our multiton cache
                 * @var array
                 */
                protected $instancesMaxAllowed = %s;
PHP
                , $instancesMaxAllowed
            )
        );

    }
819437
public int getMaximumNumberOfInstances(final InstanceType instanceType) {

		final Integer val = this.maximumMap.get(instanceType);
		if (val != null) {
			return val.intValue();
		}

		return 0;
	}
981858
private void obtainMaxNumber(@NonNull final TypedArray typedArray) {
        int defaultValue = getContext().getResources()
                .getInteger(R.integer.number_picker_preference_default_max_number);
        setMaxNumber(typedArray
                .getInteger(R.styleable.AbstractNumericPreference_android_max, defaultValue));
    }
1225563
@Override
  public IVersion getMaximum()
  {
    if (isBounded) {
      IVersion v2 = range2.getMaximum();
      return v2;
    }

    throw new UnsupportedOperationException();
  }
710336
protected function _loadMax()
    {
        $old = array_pop($this->_maxSave);

        if ($old) {
            $this->_maxX = $old[0];
            $this->_maxY = $old[1];
            $this->_maxH = $old[2];
            $this->_maxE = $old[3];
        } else {
            $this->_maxX = 0;
            $this->_maxY = 0;
            $this->_maxH = 0;
            $this->_maxE = 0;
        }
    }