Returns the maximum index value in the table.

@return int
967541
protected function _getMax()
    {
        $field = $this->_config['right'];
        $rightField = $this->_config['rightField'];
        $edge = $this->_scope($this->_table->find())
            ->select([$field])
            ->orderDesc($rightField)
            ->first();

        if (empty($edge->{$field})) {
            return 0;
        }

        return $edge->{$field};
    }
549680
public function getCurrentMax()
	{
		$max = 0;
		/* @var $node Node\NodeInterface */
		foreach ($this->array as $node) {
			$max = max($max, $node->getRightValue());
		}
		return $max;
	}
1226810
public function getMaxFileSize(): int
    {
        if ($this->maxFileSize === null) {
            $value = ini_get("upload_max_filesize");
            $units = "BKMGT";
            $unit = preg_replace("/[^$units]/i", "", $value);
            $value = floatval($value);
            if ($unit) {
                $value *= pow(1024, stripos($units, $unit[0]));
            }
            $this->maxFileSize = (int) $value;
        }
        return $this->maxFileSize;
    }
1234768
public function getMaxSort()
    {
        if ($this->_max === null) {
            $this->_max = $this->owner->find()->andWhere($this->getCondition())->count() - 1;
        }
        return $this->_max;
    }
104894
public function last()
    {
        $lastIndex = $this->count() - 1;
        if ($this->offsetExists($lastIndex)) {
            return $this->offsetGet($lastIndex);
        }
    }
283404
public function max($colName)
    {
        $max = -INF;
        foreach ($this->rows as $row) {
            if ($max<$row[$colName]) {
                $max = $row[$colName];
            }
        }
        return $max;
    }
653208
public function max()
    {
        $max = null;
        $first = false;
        foreach ($this as $v) {
            if (!$first || $v > $max) {
                $max = $v;
                $first = true;
            }
        }
        return $max;
    }
1372249
public function getMaxAge()
    {
        $cache_control = $this->getCacheControl();

        if (isset($cache_control['max-age'])) {
            $result = $cache_control['max-age'];
        } else {
            $result = (int) $this->_max_age;
        }

        return (int) $result;
    }
436806
protected function getMaxIdentifierLength()
    {
        if ($this->tableNameLengthLimit === null) {
            $this->tableNameLengthLimit = $this->entityManager->getConnection()->getDatabasePlatform()->getMaxIdentifierLength();
        }

        return $this->tableNameLengthLimit;
    }
437997
public int getMaxValueIndex(double[] array) {

        int index = 0;
        double max = Integer.MIN_VALUE;

        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
                index = i;
            }
        }

        return index;
    }
749063
public function getLast()
    {
        try {
            $query = (new SelectQueryBuilder())->select([
                'max_value' => QueryExpression::max('id')
            ])->from(static::tableName());
            $sql = $query->parse($this->connection->getDialect())->getSQL();
            $data = $this->connection->prepare($sql)->execute()->fetch();
            return $data['max_value'];
        } catch (\PDOException $e) {
            return -1;
        }
    }
847268
public int getMaxIdx() {
        int max = Integer.MIN_VALUE;
        for (int i=0; i<this.top; i++) {
            if (idx[i] > max) {
                max = idx[i];
            }
        }
        return max;
    }
810939
protected function _fetchMaxChunks() {
        $count = 'COUNT(*)';
        $model = $this->getModel();
        $select = clone $this->getSelect();
        $select->reset(Zend_Db_Select::COLUMNS)
               ->reset(Zend_Db_Select::FROM)
               ->reset(Zend_Db_Select::ORDER)
               ->reset(Zend_Db_Select::GROUP)
        ;
        $select->from($model->getName(), array('c' => $count));

        if ($max = $this->_fetchMaxChunksFromFilters($select)) {
            return $max;
        } else {
            $result = $model->fetchRow($select);
            return $result->c;
        }
    }
636584
public function get_maximum_tries() {
        $max = 1;
        foreach ($this->get_responses() as $actualresponse) {
            $max = max($max, $this->get_response($actualresponse)->get_maximum_tries());
        }
        return $max;
    }
101694
public function getMaxValue()
    {
        $values = $this->values->toArray();

        uasort($values, $this->cmpValues('getName'));

        return end($values);
    }
165183
private function maxLength()
	{
		$max = mb_strlen($this->value);
		if (!$ret = $max <= $this->options->max) {
			$this->error(1);
		}

		return $ret;
	}
451397
protected function _getMax()
	{
		$max = 0;
		if (!empty($this->_tagsArray)) {
			$p_size = 0;
			foreach ($this->_tagsArray as $cKey => $cVal) {
				$c_size = $cVal['size'];
				if ($c_size > $p_size) {
					$max = $c_size;
					$p_size = $c_size;
				}
			}
		}
		return $max;
	}