This method is called when the {@link SizeLimitExceededException} was thrown.
777622
protected void reportSizeLimitExceeded(final SizeLimitExceededException e, Validator validator) {
		validator.add(new I18nMessage("upload", "file.limit.exceeded", e.getActualSize(), e.getPermittedSize()));
		logger.warn("The file size limit was exceeded. Actual {} permitted {}", e.getActualSize(), e.getPermittedSize());
	}
295016
public void resetLimits() {
        maxLength = Long.MAX_VALUE;
        timeoutMs = Long.MAX_VALUE;
        maxRateBytesPerMs = Long.MAX_VALUE;
    }
500522
public void setLength(long size) throws IOException, RepositoryException
   {
      if (!changed)
      {
         internalData = createEditableCopy(this.getInternalData());
      }

      ((EditableValueData)internalData).setLength(size);
      invalidateStream();
   }
1111033
private <T> void addLimit(ElementDescriptor<T> descriptor, T limit)
	{
		if (mLimit == null)
		{
			mLimit = new HashMap<ElementDescriptor<?>, Object>(6);
		}
		mLimit.put(descriptor, limit);
	}
361128
@SuppressWarnings("unchecked")
  protected final void initialize(int maxSize) {
    size = 0;
    int heapSize = maxSize + 1;
    heap = (T[]) new Object[heapSize];
    this.maxSize = maxSize;
  }
1009317
void _resizeImpl(int pointCount) {
		if (pointCount < 0)
			throw new IllegalArgumentException();

		if (pointCount == m_pointCount)
			return;

		m_pointCount = pointCount;
		notifyModified(DirtyFlags.DirtyAllInternal);
	}
1073819
public void setLimits(java.util.Collection<Limit> limits) {
        if (limits == null) {
            this.limits = null;
            return;
        }

        this.limits = new java.util.ArrayList<Limit>(limits);
    }
918051
public void ensureCapacity(int size) {
    if (size > elements.length) {
      reallocate(Math.max(size, 2 * elements.length));
    }
  }
1308404
public long size(Transaction transaction)
                    throws ObjectManagerException
    {
        long size = 0;
        for (Iterator iterator = iterator(); iterator.hasNext(transaction); iterator.next(transaction)) {
            size++;
            if (size == Long.MAX_VALUE)
                break;
        } // for...
        return size;
    }
440970
@Override
    public void setMaxFieldSize(int max) throws SQLException
    {
        checkClosed();
        if (max < 0) {
            throw SQLError.get(SQLError.ILLEGAL_ARGUMENT, max);
        }
        throw SQLError.noSupport(); // Not supported by provider - no point trashing data we received from the server just to simulate the feature while not getting any gains!
    }
986399
public void setMaxHeaderTableSize(long maxHeaderTableSize) throws Http2Exception {
        if (maxHeaderTableSize < MIN_HEADER_TABLE_SIZE || maxHeaderTableSize > MAX_HEADER_TABLE_SIZE) {
            throw connectionError(PROTOCOL_ERROR, "Header Table Size must be >= %d and <= %d but was %d",
                    MIN_HEADER_TABLE_SIZE, MAX_HEADER_TABLE_SIZE, maxHeaderTableSize);
        }
        maxDynamicTableSize = maxHeaderTableSize;
        if (maxDynamicTableSize < encoderMaxDynamicTableSize) {
            // decoder requires less space than encoder
            // encoder MUST signal this change
            maxDynamicTableSizeChangeRequired = true;
            hpackDynamicTable.setCapacity(maxDynamicTableSize);
        }
    }
1071725
protected void checkLimit() {
    synchronized (this.getSyncObject()) {
      if (this.byteLimit != -1 && this.traceLogfile != null && this.traceLogfile.length() > this.byteLimit) {
        close();
        
        int pos = this.traceLogfile.getAbsolutePath().lastIndexOf('\u002e');
        String splitFilename = this.traceLogfile.getAbsolutePath().substring(0, pos) + "." + (++this.counter) + ".log";
        File splitFile = new File(splitFilename);
        if (splitFile.exists()) {
          if (!splitFile.delete())
            System.err.printf("WARNING: Couldn't delete old file: %s%n", splitFile.getName());
        }
        this.traceLogfile.renameTo(splitFile);

        open();
      }
    }
  }
711115
@Override
    public void setMaxBatchSize(final Integer maxBatchSize) {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
            SibTr.debug(this, TRACE, "setMaxBatchSize", maxBatchSize);
        }
        _maxBatchSize = maxBatchSize;
    }
1214207
@Override
  protected final void increaseNewListSize() throws IOException {
    // register old situation
    int tmpOldSize = newKeyList.length;
    int tmpNewPosition = newPosition;
    // increase
    super.increaseNewListSize();
    // reconstruct
    T1[] tmpNewAdvancedValueSumList = newAdvancedValueSumList;
    T2[] tmpNewAdvancedValueSumOfLogsList = newAdvancedValueSumOfLogsList;
    T1[] tmpNewAdvancedValueSumOfSquaresList = newAdvancedValueSumOfSquaresList;
    T1[] tmpNewAdvancedValueMinList = newAdvancedValueMinList;
    T1[] tmpNewAdvancedValueMaxList = newAdvancedValueMaxList;
    long[] tmpNewAdvancedValueNList = newAdvancedValueNList;
    newAdvancedValueSumList = operations.createVector1(newSize);
    newAdvancedValueSumOfLogsList = operations.createVector2(newSize);
    newAdvancedValueSumOfSquaresList = operations.createVector1(newSize);
    newAdvancedValueMinList = operations.createVector1(newSize);
    newAdvancedValueMaxList = operations.createVector1(newSize);
    newAdvancedValueNList = new long[newSize];
    newPosition = tmpNewPosition;
    System.arraycopy(tmpNewAdvancedValueSumList, 0, newAdvancedValueSumList, 0,
        tmpOldSize);
    System.arraycopy(tmpNewAdvancedValueSumOfLogsList, 0,
        newAdvancedValueSumOfLogsList, 0, tmpOldSize);
    System.arraycopy(tmpNewAdvancedValueSumOfSquaresList, 0,
        newAdvancedValueSumOfSquaresList, 0, tmpOldSize);
    System.arraycopy(tmpNewAdvancedValueMinList, 0, newAdvancedValueMinList, 0,
        tmpOldSize);
    System.arraycopy(tmpNewAdvancedValueMaxList, 0, newAdvancedValueMaxList, 0,
        tmpOldSize);
    System.arraycopy(tmpNewAdvancedValueNList, 0, newAdvancedValueNList, 0,
        tmpOldSize);
  }
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();
    }
  }
1205672
public void ensureSize(int maxPartitionOrder) {
        if (capacityByOrder >= maxPartitionOrder) return;
        parameters = new int[(1 << maxPartitionOrder)];
        rawBits = new int[(1 << maxPartitionOrder)]; 
        capacityByOrder = maxPartitionOrder;
    }
51406
def _enforce_size_limit(self, capacity):
        """"""
        while len(self._cache) > capacity:
            key, value = self._cache.popitem(last=False)
            if self._on_evict is not None:
                self._on_evict(key, value)