Set the maximum number of actives Sip Application Sessions allowed, or -1
for no limit.

@param max
The new maximum number of sip application sessions
504763
public void setMaxActiveSipApplicationSessions(int max) {
		int oldMaxActiveSipApplicationSessions = this.sipManagerDelegate.getMaxActiveSipApplicationSessions();
		this.sipManagerDelegate.setMaxActiveSipApplicationSessions(max);
		support
				.firePropertyChange(
						"maxActiveSipApplicationSessions",
						Integer.valueOf(oldMaxActiveSipApplicationSessions),
						Integer.valueOf(
								this.sipManagerDelegate.getMaxActiveSipApplicationSessions()));
	}
115559
synchronized void setLimits(int txnsPerSec, int maxOutstanding) {
        m_autoTune = false;
        /*
         * If the rate limit is some reasonably low value then go through the effort
         * of rate limiting
         */
        if (txnsPerSec < Integer.MAX_VALUE / 2) {
            m_doesAnyTuning = true;
        }
        m_targetTxnsPerSecond = txnsPerSec;
        m_maxOutstandingTxns = maxOutstanding;
        m_outstandingTxnsSemaphore.drainPermits();
        m_outstandingTxnsSemaphore.release(maxOutstanding);
    }
1192329
public void setLimits(java.util.Collection<Limit> limits) {
        if (limits == null) {
            this.limits = null;
            return;
        }

        this.limits = new com.amazonaws.internal.SdkInternalList<Limit>(limits);
    }
108586
public void setMax(Double max) {
        String maxStr = doubleToNiceStr(max);
        JQMCommon.setAttribute(input, "max", maxStr);
        refreshMax(input.getElement().getId(), maxStr);
        validateValue();
    }
1141713
public final void setMaxValue(final int maxValue) {
        Condition.INSTANCE.ensureGreater(maxValue, getMinValue(),
                "The maximum value must be greater than the minimum value");
        this.maxValue = maxValue;
        setValue(Math.min(getValue(), maxValue));
    }
1223083
private void setMax(MtasRBTreeNode n) {
    n.max = n.right;
    if (n.leftChild != null) {
      n.max = Math.max(n.max, n.leftChild.max);
    }
    if (n.rightChild != null) {
      n.max = Math.max(n.max, n.rightChild.max);
    }
  }
797486
public void setConcurrencyLimit(int maxConcurrency)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "setConcurrencyLimit", Integer.valueOf(maxConcurrency));

    boolean resumeConsumers = false;
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
      SibTr.debug(tc, "maxActiveMessagePrepareWriteLock.lock(): " + maxActiveMessagePrepareLock);
    
    // Fully lock down the active message counting
    maxActiveMessagePrepareWriteLock.lock();
    
    try
    {
      synchronized(maxActiveMessageLock)
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          SibTr.debug(tc, "Inital active Messages: current: " + currentActiveMessages +
                            ", prepared: " + preparedActiveMessages +
                            ", maximum: " + maxActiveMessages +
                            " (suspended: " + consumerSetSuspended + ")");
        
        // A value of zero indicates no maximum
        if(maxConcurrency == 0)
        {
          maxActiveMessages = Integer.MAX_VALUE;
          resumeThreshold = Integer.MAX_VALUE;
        }
        else
        {
          maxActiveMessages = maxConcurrency;
          
          // Set the resumeThreshold to 80% of this value.
          float res = (maxActiveMessages * 8);
          res = Math.round(res / 10);
          this.resumeThreshold = (int) res;
        }
        
        // Check that changing the limit doesn't change our current
        // suspend state
        if(currentActiveMessages > maxActiveMessages)
          consumerSetSuspended = true;
        else if(consumerSetSuspended && (currentActiveMessages < resumeThreshold))
        {
          consumerSetSuspended = false;
          resumeConsumers = true;
        }
      } // synchronized
    }
    finally
    {
      maxActiveMessagePrepareWriteLock.unlock();

      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        SibTr.debug(tc, "maxActiveMessagePrepareWriteLock.unlock(): " + maxActiveMessagePrepareLock);
    }
    
    // We may have caused the set to be resumed - wakeup any suspended
    // members of the set.
    if(resumeConsumers)
      resumeConsumers();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(this, tc, "setConcurrencyLimit");    
  }
480362
int setMaxInactToZero(String sessId, String appName) {
        final boolean trace = TraceComponent.isAnyTracingEnabled();

        int rc = -1;
        while (rc == -1) {
            if (trace && tc.isDebugEnabled())
                tcInvoke(tcSessionMetaCache, "get", sessId);

            ArrayList<?> oldValue = sessionMetaCache.get(sessId);

            if (trace && tc.isDebugEnabled())
                tcReturn(tcSessionMetaCache, "get", oldValue);

            SessionInfo sessionInfo = oldValue == null ? null : new SessionInfo(oldValue).clone();
            if (sessionInfo == null || sessionInfo.getMaxInactiveTime() == 0) {
                rc = 0;
            } else {
                sessionInfo.setMaxInactiveTime(0);
                ArrayList<Object> newValue = sessionInfo.getArrayList();

                if (trace && tc.isDebugEnabled())
                    tcInvoke(tcSessionMetaCache, "replace", sessId, oldValue, newValue);

                if (sessionMetaCache.replace(sessId, oldValue, newValue))
                    rc = 1;

                if (trace && tc.isDebugEnabled())
                    tcReturn(tcSessionMetaCache, "replace", rc == 1);
            }
        }

        return rc;
    }
1157126
public void setMaxRetryTimeMillis(long maxRetryTimeMillis) {
        if (this.httpClient instanceof DefaultHttpClient) {
            ((DefaultHttpClient) this.httpClient).setMaxRetryTimeMillis(maxRetryTimeMillis);
        }
        else
            throw new UnsupportedOperationException("Invalid operation for class " + this.httpClient.getClass());
    }
594104
public void setMax(final String pmax) {
    try {
      this.setMax(this.numberParser.parse(pmax));
    } catch (final ParseException e) {
      this.setMax((T) null);
    }
  }
403008
public void setMinMax(int min, int max)
    {
        if(min >= max)
            throw new IllegalArgumentException("The input minimum (" + min + ") must be less than the given max (" + max  + ")");
        this.min = min;
        this.max = max;
    }
466674
@Override
    public void setLimitOnNumberOfHeaders(int size) {
        if (0 >= size) {
            throw new IllegalArgumentException("Invalid limit on number headers: " + size);
        }
        this.limitNumHeaders = size;
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Limit on number of headers now: " + this.limitNumHeaders);
        }
    }
357259
public void setIdleMax(int idleMax)
  {
    if (idleMax <= _idleMin) {
      throw new IllegalArgumentException(L.l("idle-max '{0}' must be greater than idle-min '{1}'.",
                                             idleMax, _idleMin));
    }

    _launcher.setIdleMax(_idleMax);
  }
211730
public void setMax(final T pmax) {
    if (pmax == null) {
      getInputElement().removeAttribute("max");
    } else {
      getInputElement().setMax(this.numberRenderer.render(pmax));
    }
  }
634706
@Nonnull
  public FineUploader5Core setMaxConnections (@Nonnegative final int nMaxConnections)
  {
    ValueEnforcer.isGT0 (nMaxConnections, "MaxConnections");
    m_nCoreMaxConnections = nMaxConnections;
    return this;
  }
598629
@Nonnull
  public FineUploaderBasic setMaxConnections (@Nonnegative final int nMaxConnections)
  {
    ValueEnforcer.isGT0 (nMaxConnections, "MaxConnections");
    m_nMaxConnections = nMaxConnections;
    return this;
  }
263406
public function setMax($max)
    {
        
    	// Support .x notation.
    	if (!empty($max)){
        	$this->max = preg_replace('/x/u', '99999', $max);
    	}
    	else{
    		$this->max = null;
    	}
        
    }