Maximum number of items that can be potentially uploaded in this session.
Will reject all items that are added or retried after this limit is
reached.

@param nItemLimit
Minimum size limit. 0 == unlimited
@return this for chaining
514893
@Nonnull
  public FineUploader5Validation setItemLimit (@Nonnegative final int nItemLimit)
  {
    ValueEnforcer.isGE0 (nItemLimit, "ItemLimit");
    m_nValidationItemLimit = nItemLimit;
    return this;
  }
777540
public SettingsPack uploadRateLimit(int value) {
        sp.set_int(settings_pack.int_types.upload_rate_limit.swigValue(), value);
        return this;
    }
1280756
public static List<VoltXMLElement> buildLimitElements(int limit, String limitValueElementId) {
        if (limitValueElementId == null) { return null; }

        List<VoltXMLElement> retval = new ArrayList<VoltXMLElement>();
        retval.add( new VoltXMLElement("offset") );

        VoltXMLElement limitElement = new VoltXMLElement("limit");
        String strLimit = String.valueOf( limit );
        limitElement.attributes.put( "limit", strLimit );
        limitElement.children.add( buildValueElement( limitValueElementId, false, strLimit, "BIGINT" ) );
        retval.add( limitElement );
        return retval;
    }
7418
public Mappings limit(int limit) {
        return new Mappings(query, target, Iterables.limit(iterable, limit));
    }
1111033
private <T> void addLimit(ElementDescriptor<T> descriptor, T limit)
	{
		if (mLimit == null)
		{
			mLimit = new HashMap<ElementDescriptor<?>, Object>(6);
		}
		mLimit.put(descriptor, limit);
	}
751747
protected function validateLimit(): void
    {
        $limit = $this->getArrayValue($this->joryArray, ['lmt', 'limit']);

        // No limit set, that's ok. return.
        if ($limit === null) {
            return;
        }

        if (! is_int($limit)) {
            throw new JoryException('The limit parameter should be an integer value. (Location: '.$this->address.'limit)');
        }
    }
1013663
private function setLimit()
    {
        if (isset($this->requestParams['start']) && -1 != $this->requestParams['length']) {
            $this->qb->setFirstResult($this->requestParams['start'])->setMaxResults($this->requestParams['length']);
        }

        return $this;
    }
215002
public static function setMaximumCachedFiles($newLimit)
    {
        self::$maximumCachedFiles = $newLimit;
        if (count(self::$parsedFiles) > $newLimit) {
            self::$parsedFiles = array_slice(self::$parsedFiles, 0, $newLimit);
        }
    }
534932
public void setLimits(int maxConPerRoute, int maxConTotal) {
        this.maxConnPerRoute = maxConPerRoute;
        this.maxConnTotal = maxConTotal;
        if ( asyncHttpClient != null ) {
            try {
                asyncHttpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            asyncHttpClient = null;
        }
    }
192115
def limit(value = nil, &block)
      chain { criteria.update_request_options size: block || Integer(value) }
    end
1351873
public function setLimit(int $limit)
    {
        $this->limit = $limit;
        if ($this->limit < $this->batchSize) {
            $this->batchSize = $this->limit;
        }

        return $this;
    }
512436
@Override
    public void registerLimit(final long limit) {

        if (queues.size() > 0) {
            if (unlimited.get(currentQueue())
                         .get())
                limits.get(currentQueue())
                      .set(0);

            limits.get(currentQueue())
                  .addAndGet(limit);
            unlimited.get(currentQueue())
                     .set(false);

            queues.stream()
                  .forEach(this::closeQueueIfFinishedStateless);

        }
    }
1249411
@Nonnull
  public Query limit(int limit) {
    QueryOptions newOptions = new QueryOptions(options);
    newOptions.limit = limit;
    return new Query(firestore, path, newOptions);
  }
991563
public void setLimits(int softLimit, int hardLimit) {
    if ((softLimit > 0 && hardLimit > softLimit) || (softLimit == 0 && hardLimit == 0)) {
      this.softLimit = softLimit;
      this.hardLimit = hardLimit;
      garbageCollect();
    } else {
      throw new IllegalArgumentException();
    }
  }
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.");
    }
  }
456672
@Override
    public final IntStream limit(long maxSize) {
        if (maxSize < 0)
            throw new IllegalArgumentException(Long.toString(maxSize));
        return SliceOps.makeInt(this, 0, maxSize);
    }
515830
public Subscription limitValidity( String subscription, String newValidity ) {
    return limitValidity( new Subscription( subscription ), newValidity );
  }