Is a max row limit indicated?

@param selection The row selection options
@return Whether a max row limit was indicated
761565
public static boolean hasMaxRows(RowSelection selection) {
		return selection != null && selection.getMaxRows() != null && selection.getMaxRows() > 0;
	}
193363
public static boolean isLimited(String string, int min, int max) {
        return isNotEmpty(string) && string.length() >= min && string.length() <= max;
    }
187185
private boolean selectACollection()
    {
        if (!cfm.comparator.hasCollections())
            return false;

        for (ColumnDefinition def : selection.getColumns())
        {
            if (def.type.isCollection() && def.type.isMultiCell())
                return true;
        }

        return false;
    }
175028
function () {
            var maxCount = 0, suggestion = this.controller.selectedSuggestions;
            if (suggestion.length < this.controller.maxOptions) {
                return this.controller.maxOptions;
            } else {
                for (var i = 0, len = suggestion.length; i < len; i++) {
                    if (ariaUtilsType.isObject(suggestion[i])) {
                        maxCount++;
                    }
                }
                return maxCount;
            }
        }
552623
public boolean isAllSelected()
    {
        boolean bAllSelected = true;
        for (int iFieldSeq = DBConstants.MAIN_FIELD; iFieldSeq <= this.getFieldCount() + DBConstants.MAIN_FIELD - 1; iFieldSeq++)
        {
            if(this.getField(iFieldSeq).isSelected() == false)
                bAllSelected = false;
        }
        return bAllSelected;
    }
1366176
private void paintRowSelectionElement(final WDataTable table, final XmlStringBuilder xml) {
		boolean multiple = table.getSelectMode() == SelectMode.MULTIPLE;

		xml.appendTagOpen("ui:rowselection");
		xml.appendOptionalAttribute("multiple", multiple, "true");

		if (multiple) {
			switch (table.getSelectAllMode()) {
				case CONTROL:
					xml.appendAttribute("selectAll", "control");
					break;
				case TEXT:
					xml.appendAttribute("selectAll", "text");
					break;
				case NONE:
					break;
				default:
					throw new SystemException("Unknown select-all mode: " + table.
							getSelectAllMode());
			}
		}

		xml.appendOptionalAttribute("groupName", table.getSelectGroup());
		xml.appendEnd();
	}
51578
public boolean isRowPresent(String searchElement) {
        ready();
        Cell cell = getCell(searchElement);
        return cell.isElementPresent();
    }
1066347
def selection_range(self):
        
        selected = self.selectionModel().selection()
        """:type: QItemSelection """

        if selected.isEmpty():
            return -1, -1, -1, -1

        min_row = numpy.min([rng.top() for rng in selected])
        max_row = numpy.max([rng.bottom() for rng in selected])
        start = numpy.min([rng.left() for rng in selected])
        end = numpy.max([rng.right() for rng in selected]) + 1

        return min_row, max_row, start, end
550271
public void checkLimit(int len) {
        if(cursor == -1) {
            cursor = buffer.start;
            lineptr = buffer.start;
            linectptr = buffer.start;
            marker = buffer.start;
        }
        limit = buffer.start + len;
    }
1051049
private boolean query()
		throws SQLException
	{
		statement = this.connection.createStatement();

		String query = "SELECT PrimaryKey, RevisionCounter,"
				+ " RevisionID, ArticleID, Timestamp, FullRevisionID "
				+ "FROM revisions";

		if (primaryKey > 0) {
			query += " WHERE PrimaryKey > " + primaryKey;
		}

		if (MAX_NUMBER_RESULTS > 0) {
			query += " LIMIT " + MAX_NUMBER_RESULTS;
		}

		result = statement.executeQuery(query);
		return result.next();
	}
1191779
public void select(ArrayList selection) {
		list.clearSelection();
		int[] selected = new int[selection.size()];
		for (int i=0;i<selection.size();i++) {
			selected[i] = sprites.indexOf(selection.get(i));
		}
		list.setSelectedIndices(selected);
		
		sheetPanel.setSelection(selection);
	}
429168
public <T extends IItem & IExpandable> void selectRange(int from, int to, boolean select) {
        selectRange(from, to, select, false);
    }
975164
def max_number(self, rows: List[Row], column: NumberColumn) -> Number:
        
        cell_values = [row.values[column.name] for row in rows]
        if not cell_values:
            return 0.0  # type: ignore
        if not all([isinstance(value, Number) for value in cell_values]):
            raise ExecutionError(f"Invalid values for number selection function: {cell_values}")
        return max(cell_values)
661193
protected function applyLimitConditions(ISelectBuilder $selectBuilder)
    {
        if ($this->limit) {
            $postfix = self::PLACEHOLDER_SEPARATOR . $this->collection->getName();

            $limitPlaceholder = ':limit' . $postfix;
            $offsetPlaceholder = ':offset' . $postfix;

            $selectBuilder
                ->limit($limitPlaceholder)
                ->bindInt($limitPlaceholder, $this->limit);
            if ($this->offset) {
                $selectBuilder
                    ->offset($offsetPlaceholder)
                    ->bindInt($offsetPlaceholder, $this->offset);
            }
        }
    }
646615
public boolean isMultipleSelect()
        throws CacheReloadException
    {
        final boolean ret;
        if (isRoot()) {
            ret = this.multipleSelect;
        } else {
            ret = getParentClassification().isMultipleSelect();
        }
        return ret;
    }
101125
public void filterUpdate(String columnId, int row, Integer maxSelections) {
        if (displayerSettings.isFilterEnabled()) {

            List<Interval> selectedIntervals = columnSelectionMap.get(columnId);
            Interval intervalFiltered = filterInterval(columnId, row);

            // Existing interval reset
            if (intervalFiltered != null) {
                selectedIntervals.remove(intervalFiltered);
                if (!selectedIntervals.isEmpty()) {
                    filterApply(columnId, selectedIntervals);
                }
                else {
                    filterReset(columnId);
                }
            }
            // No current filter => Add the selected interval
            else if (selectedIntervals == null) {
                Interval intervalSelected = dataSetHandler.getInterval(columnId, row);
                if (intervalSelected != null) {
                    selectedIntervals = new ArrayList<>();
                    selectedIntervals.add(intervalSelected);
                    columnSelectionMap.put(columnId, selectedIntervals);
                    filterApply(columnId, selectedIntervals);
                }
            }
            // Extra interval added to an already filtered column
            else {
                Interval intervalSelected = dataSetHandler.getInterval(columnId, row);
                if (intervalSelected != null) {
                    if (displayerSettings.isFilterSelfApplyEnabled()) {
                        selectedIntervals = new ArrayList<>();
                        columnSelectionMap.put(columnId, selectedIntervals);
                    }
                    selectedIntervals.add(intervalSelected);
                    if (maxSelections != null && maxSelections > 0 && selectedIntervals.size() >= maxSelections) {
                        filterReset(columnId);
                    } else {
                        filterApply(columnId, selectedIntervals);
                    }
                }
            }
        }
    }
933256
private void checkLimitRange(int limit) {
    int minLimit = offsetPaginationConfiguration.allowZeroLimit() ? 0 : 1;

    if (limit < minLimit || limit > offsetPaginationConfiguration.maxLimit()) {
      throw InvalidParameterException.create(
          "Invalid value for '" + this.getParameterFieldName() + "': " + limit
              + "  - value between " + minLimit + " and " + offsetPaginationConfiguration.maxLimit()
              + " is required.");
    }
  }