Ueberprueft, ob der uebergebenen Werte innerhalb der min/max-Werte
liegt.

@param wert zu ueberpruefender Wert
@return den ueberprueften Wert (zur Weiterverarbeitung)
437106
@Override
    public T validate(T wert) {
        if (!isValid(wert)) {
            throw new InvalidLengthException(Objects.toString(wert), min, max);
        }
        return wert;
    }
790681
public Polar boundaryGap(Object min, Object max) {
        this.boundaryGap = new Object[]{min, max};
        return this;
    }
307668
@Override
    public BigDecimal apply(ChronoEntity<?> context) {

        long value = context.get(this.element).longValue();
        long min = context.getMinimum(this.element).longValue();
        long max = context.getMaximum(this.element).longValue();

        if (value > max) {
            value = max; // Schutz gegen Anomalien
        }

        if (value == min) {
            return BigDecimal.ZERO;
        }

        if (
            this.extendedRange
            && (context instanceof PlainTime)
            && !PlainTime.class.cast(context).hasReducedRange(this.element)
        ) {
            if (value == max) {
                return BigDecimal.ONE;
            }
            max--;
        }

        BigDecimal count = new BigDecimal(value - min).setScale(15, RoundingMode.UNNECESSARY);
        BigDecimal divisor = new BigDecimal(max - min + 1);

        return count.divide(divisor, RoundingMode.HALF_UP).stripTrailingZeros();

    }
491658
public Integer max(IntBinaryTree tree)  {
        return tree.match(new IntBinaryTree.MatchBlock<Integer>() {
           @Override
           public Integer _case(Node x) {
              final Integer maxLeft = max(x.left);
              final int l = maxLeft == null ? Integer.MIN_VALUE : maxLeft;

              final Integer maxRight = max(x.right);
              final int r = maxRight == null ? Integer.MIN_VALUE : maxRight;

              return Math.max(Math.max(l, r), x.value);
           }

           @Override
           public Integer _case(EmptyTree x) {
              return null;
           }
        });
     }
573616
public T argMax() {
        double maxCount = -Double.MAX_VALUE;
        T maxKey = null;
        for (Map.Entry<T, AtomicDouble> entry : map.entrySet()) {
            if (entry.getValue().get() > maxCount || maxKey == null) {
                maxKey = entry.getKey();
                maxCount = entry.getValue().get();
            }
        }
        return maxKey;
    }
1040950
public static ArgumentValidator atMost(final int expectedMax) {
        switch (expectedMax) {
            case 0:
                return NO_ARGUMENTS;
            case 1:
                return _AT_MOST_ONE;
            case 2:
                return _AT_MOST_TWO;
        }
        return atMost(expectedMax, MessageFormat.format("0..{0}", expectedMax));
    }
770103
public double getMax() {
        double max = s.minValue();
        for (int c = 0; c < this.size(); c++) {
            double val = getValue(c);
            if (s.gte(val, max)) {
                max = val;
            }
        }
        return max;
    }
152865
@Pure
	public DoubleProperty radiusProperty() {
		if (this.radius == null) {
			this.radius = new SimpleDoubleProperty(this, MathFXAttributeNames.RADIUS) {
				@Override
				protected void invalidated() {
					if (get() < 0.) {
						set(0.);
					}
				}
			};
		}
		return this.radius;
	}
567193
public BigInteger getBigInteger() throws IOException {
        if (buffer.read() != DerValue.tag_Integer) {
            throw new IOException("DER input, Integer tag error");
        }
        return buffer.getBigInteger(getLength(buffer), false);
    }
416846
public AABBf setMax(Vector3fc max) {
        return this.setMax(max.x(), max.y(), max.z());
    }
1277470
@Override
    public boolean isValid(String wert) {
        if (StringUtils.length(wert) < 1) {
            return false;
        } else {
            return getPruefziffer(wert).equals(berechnePruefziffer(wert.substring(0, wert.length() - 1)));
        }
    }
1232603
public RetryInterceptorBuilder<T> maxAttempts(int maxAttempts) {
		Assert.isNull(this.retryOperations,
				"cannot alter the retry policy when a custom retryOperations has been set");
		Assert.isTrue(!this.retryPolicySet,
				"cannot alter the retry policy when a custom retryPolicy has been set");
		this.simpleRetryPolicy.setMaxAttempts(maxAttempts);
		this.retryTemplate.setRetryPolicy(this.simpleRetryPolicy);
		this.templateAltered = true;
		return this;
	}
1178871
@Pure
	public DoubleProperty heightProperty() {
		if (this.height == null) {
			this.height = new SimpleDoubleProperty(this, MathFXAttributeNames.HEIGHT);
			this.height.bind(Bindings.subtract(maxYProperty(), minYProperty()));
		}
		return this.height;
	}
589025
public DoubleParameter setMaximumValue(double maximumValue, boolean inclusive) {
		if (hasDefaultValue) {
			if (inclusive) {
				Util.checkParameter(maximumValue >= defaultValue,
					"Maximum value (" + maximumValue + ") must be greater than or equal to default (" + defaultValue + ")");
			} else {
				Util.checkParameter(maximumValue > defaultValue,
					"Maximum value (" + maximumValue + ") must be greater than default (" + defaultValue + ")");
			}
		} else if (hasMinimumValue) {
			if (inclusive && minimumValueInclusive) {
				Util.checkParameter(maximumValue >= minimumValue,
					"Maximum value (" + maximumValue + ") must be greater than or equal to minimum (" + minimumValue + ")");
			} else {
				Util.checkParameter(maximumValue > minimumValue,
					"Maximum value (" + maximumValue + ") must be greater than minimum (" + minimumValue + ")");
			}
		}

		this.hasMaximumValue = true;
		this.maximumValue = maximumValue;
		this.maximumValueInclusive = inclusive;

		return this;
	}
468142
public T max() {
        TObjectIntIterator<T> iter = counts.iterator();
        int maxCount = -1;
        T max = null;
        while (iter.hasNext()) {
            iter.advance();
            int count = iter.value();
            if (count > maxCount) {
                max = iter.key();
                maxCount = count;
            }
        }
        return max;
    }
1199083
@NotNull
    public OptionalDouble min() {
        return reduce(new DoubleBinaryOperator() {
            @Override
            public double applyAsDouble(double left, double right) {
                return Math.min(left, right);
            }
        });
    }
643714
protected function getFirstViewBlockerId()
	{
	    $this->getSession('FirstViewBlocker'.$this->module_id);
	    if ( count($this->_session) )
	    {
	        $key    = key($this->_session);
	        $tstmap = current($this->_session);
	        reset($this->_session);
	        if ( $this->removeOldFirstViewBlockerId($key, $tstmap) === true ) 
	        {
	            // Key ist noch gültig und es muss daher geblockt werden
	            //DEBUG log_message('getFirstViewBlockerId Banner Kat ID: '.$key,'Banner.log');
	            return $key;
	        }
	    }
	    return false;
	}