Marks a field as having a maximum acceptable value

@param int|float $max The maximum value to compare against
@param bool $isInclusive Whether or not the maximum is inclusive
@return self For method chaining
767608
public function max($max, bool $isInclusive = true) : self
    {
        $this->createRule(MaxRule::class, [$max, $isInclusive]);

        return $this;
    }
1087395
function setMaxPointsTeam($max, $multicall = false)
    {
        if (!is_int($max)) {
            throw new InvalidArgumentException('max = ' . print_r($max, true));
        }

        return $this->execute(ucfirst(__FUNCTION__), array($max), $multicall);
    }
386039
public function setMaxNbColumns($maxNbColumns)
    {
        $this->minNbColumns = min($this->minNbColumns, $maxNbColumns);
        $this->maxNbColumns = $maxNbColumns;

        return $this;
    }
680886
public function setMax($max)
    {
        if (!is_string($max) && !is_numeric($max)) {

            throw new Zend_Validate_Exception ('Invalid options to validator provided');
        }

        $max = (integer) $this->_fromByteString($max);
        $min = $this->getMin(true);
        if (($min !== null) && ($max < $min)) {

            throw new Zend_Validate_Exception("The maximum must be greater than or equal to the minimum filesize, but "
                                            . "$max < $min");
        }

        $this->_max = $max;
        return $this;
    }
996673
public function setMax($max)
    {
        if (is_numeric($max) || Format::isVariableRef($max)) {
            $this->max = $max;
        } else {
            $msg = "'Max must be a numeric value or a variableRef, '" . gettype($max) . "' given.";
            throw new InvalidArgumentException($msg);
        }
    }
839408
public function setAllowedMaxWidth(float $allowed_max_width) {
        if(!$this->setModified('allowed_max_width', $allowed_max_width)->isModified()) {
            return $this;
        }
		$this->allowed_max_width = $allowed_max_width;
		return $this;
    }
496179
public static function isOptionalIntegerRange($value, $min, $max)
    {
        /* No additional validations when the value is null. */
        if (null === $value) {

            return true;
        }

        return self::isRequiredIntegerRange($value, $min, $max);
    }
225173
final public function max($field)
    {

        if (!is_array($fields)) {
            if (strpos($fields, ',') !== FALSE) {
                $fields = explode(',', $fields);
            } else {
                $fields = array($fields);
            }
        }

        foreach ($fields as $field) {
            $field = trim($field);
            if (!is_int($field) && empty($field)) {
                continue; //if empty and not zero?
            }
            $this->arraySelect[] = $field;

            if ($this->arrayCaching) {
                $this->arrayCacheSelect[] = $field;
                $this->arrayCacheExists[] = 'select';
            }
        }

        return $this;
    }
1247391
public function between($min, $max, $includeMin = true, $includeMax = true) {
        if (!$this->_isValid) {
            return $this;
        }

        if ($this->_unsafeVar < $min) {
            $this->_isValid = false;
        } else if ($this->_unsafeVar > $max) {
            $this->_isValid = false;
        } else if ($this->_unsafeVar == $min && !$includeMin) {
            $this->_isValid = false;
        } else if ($this->_unsafeVar == $max && !$includeMax) {
            $this->_isValid = false;
        }
        return $this;
    }
1330237
public function visitMaximumPropertiesConstraint(ObjectValue\MaximumPropertiesConstraint $constraint)
    {
        $value = $this->currentValue();
        if (
            !$value instanceof Value\ObjectValue ||
            $value->count() <= $constraint->maximum()
        ) {
            return $this->createResult();
        }

        return $this->createSingleIssueResult($constraint);
    }
559662
public static function max($val, $max)
	{
	    if (is_array($max)) {
	        if (!isset($max['max'])) {
	            throw new \InvalidArgumentException('The $max argument must have "max" key');
	        }
	        $max = $max['max'];
	    }

	    return $val <= $max;
	}
1341303
public function limitSize($max) {
		// if the maximum is not numeric
		if(is_numeric($max)) {
			// set maximum
			$this->Limits->Size = intval($max);
		}
		// return self
		return($this);
	}
380047
public function setMaxResults($maxResults)
    {
        $this->limit = $maxResults;
        
        if( $this->query instanceof Query )
        {
            $this->query->setMaxResults($maxResults);
        }

        return $this;
    }
590748
public function setMax(int $max): void{
        if($this->min > $max){
            throw new \InvalidArgumentException();
        }

        $this->max  = $max;
    }
1325608
private function max($value, $max)
    {
        if (is_string($value)) {
            $value = strlen($value);
        }

        return $value <= $max;
    }
306359
public function setMax(float $max) : Number
    {
        $this->attributes['max'] = $max;
        return $this->addTest('max', function ($value) use ($max) {
            return $value <= $max;
        });
    }
368196
public static function isOptionalFloatRange($value, $min, $max)
    {
        /* No additional validations when the value is null. */
        if (null === $value) {

            return true;
        }

        return self::isRequiredFloatRange($value, $min, $max);
    }