Allows the mbean, or dynamic config to set the destination limits currently used
by this localization.

@param newDestLowMsgs
430132
public void setDestLowMsgs(long newDestLowMsgs)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "setDestLowMsgs", Long.valueOf(newDestLowMsgs));

        setDestLimits(_destHighMsgs, newDestLowMsgs);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "setDestLowMsgs");
    }
851819
@Override
	public final void setJMSDestination(Destination destination) throws JMSException
    {
    	assertDeserializationLevel(MessageSerializationLevel.FULL);
        this.destination = DestinationTools.asRef(destination);
    }
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);
        }
    }
612621
public void setLimits(long length, long milliseconds, long rateKBps) {
        maxLength = (length>0) ? length : Long.MAX_VALUE;
        timeoutMs = (milliseconds>0) ? milliseconds : Long.MAX_VALUE;
        maxRateBytesPerMs = (rateKBps>0) ? rateKBps*1024/1000 : Long.MAX_VALUE;
    }
152201
@Override
  public void exitStandardMessageOptionMessageSetWireFormat(
      final StandardMessageOptionMessageSetWireFormatContext ctx) {
    verifyOptionNameUnique("messageSetWireFormat", ctx.getStart());
    scopes.getMessageOptions().setMessageSetWireFormat(
        Boolean.valueOf(ctx.BooleanLiteral().getText()));
  }
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");    
  }
481845
protected static void checkMessageSize(Object message, long maxMessageSize) {
        if (maxMessageSize != -1) {
            final long messageSize =
                    (message instanceof String ? ((String) message).getBytes(Charset.defaultCharset()).length
                            : ((ByteBuffer) message).remaining());

            if (messageSize > maxMessageSize) {
                throw new MessageTooBigException(
                        Messages.get("web.socket.error.message.too.long", maxMessageSize, messageSize)
                );
            }
        }
    }
1065328
private void send(Message message, String destinationName, TestContext context) {
        if (log.isDebugEnabled()) {
            log.debug("Sending JMS message to destination: '" + destinationName + "'");
        }

        endpointConfiguration.getJmsTemplate().send(destinationName, session -> {
            javax.jms.Message jmsMessage = endpointConfiguration.getMessageConverter().createJmsMessage(message, session, endpointConfiguration, context);
            endpointConfiguration.getMessageConverter().convertOutbound(jmsMessage, message, endpointConfiguration, context);
            return jmsMessage;
        });

        log.info("Message was sent to JMS destination: '" + destinationName + "'");
    }
1297718
public void setLimit(int limit) {
        FailureInterpreter fi = getFailureInterpreter();
        if (!(fi instanceof DefaultFailureInterpreter)) {
            throw new IllegalStateException("setLimit() not supported: this CircuitBreaker's FailureInterpreter isn't a DefaultFailureInterpreter.");
        }
        ((DefaultFailureInterpreter)fi).setLimit(limit);
    }
693224
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
  public CallOptions withMaxInboundMessageSize(int maxSize) {
    checkArgument(maxSize >= 0, "invalid maxsize %s", maxSize);
    CallOptions newOptions = new CallOptions(this);
    newOptions.maxInboundMessageSize = maxSize;
    return newOptions;
  }
286246
public void busReloaded(final LWMConfig newBus, final boolean busChanged,
            final boolean destinationsChanged, final boolean mediationsChanged) {

        final String methodName = "busReloaded";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName, new Object[] { newBus,
                    Boolean.valueOf(busChanged),
                    Boolean.valueOf(destinationsChanged),
                    Boolean.valueOf(mediationsChanged) });
        }

        RELOADING_MESSAGING_ENGINES.add(_messagingEngine.getUuid().toString());

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }

    }
695343
@Override
  public void localizeConfiguration(JobConf conf) throws IOException {
    super.localizeConfiguration(conf);
    conf.setNumMapTasks(numMaps);
  }
490331
public void setValue(int numStrings, String[] newValues) {
        value.clear();
        if (numStrings == newValues.length) {
            for (int i = 0; i < newValues.length; i++) {
                value.add(newValues[i]);
            }
        }
        else {
            Log.e(TAG, "X3D MFString setValue() numStrings not equal total newValues");
        }
    }
1193509
public void setAvailablePortSpeeds(java.util.Collection<String> availablePortSpeeds) {
        if (availablePortSpeeds == null) {
            this.availablePortSpeeds = null;
            return;
        }

        this.availablePortSpeeds = new com.amazonaws.internal.SdkInternalList<String>(availablePortSpeeds);
    }
210417
protected void warning(int no, String msg, ILexLocation location)
	{
		VDMWarning vdmwarning = new VDMWarning(no, msg, location);
		warnings.add(vdmwarning);

		if (warnings.size() >= MAX - 1)
		{
			errors.add(new VDMError(9, "Too many warnings", location));
			throw new InternalException(9, "Too many warnings");
		}
	}
580816
public void addWarningMsgs(final Set<String> msgs) {
    if (msgs != null) {
      this._warningMsgs.addAll(msgs);
      if (!msgs.isEmpty() && this._errorMsgs.isEmpty()) {
        this._status = ValidationStatus.WARN;
      }
    }
  }
367688
private void applyVerticalLimit()
    {
        if (mover.getY() < limitBottom && limitBottom != Integer.MIN_VALUE)
        {
            mover.teleportY(limitBottom);
        }
        else if (mover.getY() > limitTop && limitTop != Integer.MAX_VALUE)
        {
            mover.teleportY(limitTop);
        }
    }