f743-7046 moved code from other createEndpoint to this method and modified it for timeout parameter.
965224
@Override
    public MessageEndpoint createEndpoint(XAResource xaResource, long timeout) throws UnavailableException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            Tr.entry(tc, "MEF.createEndpoint for enterprise class " + beanMetaData.enterpriseBeanName);
        }

        boolean recoverableXAResource = false;
        // d197017 begins
        // Make sure endpoint is activated before proceeding.
        Object proxy = null;
        MessageEndpointBase endpoint = null;
        boolean newInstanceRequired = false; //LI2110.56
        synchronized (ivStateLock)
        {
            // If RRS then xaResource passed in may be null. We need to enlist the RRS XAResource and not the XAResource passed in by the
            // RA. So in that case we need to check for the recoveryId
            if (xaResource != null || ivRRSTransactional) //d197017
            {
                // Ensure setRecoveryID method is called prior to this method since
                // recovery ID is needed to enlist the XAResource with the
                // transaction service during beforeDelivery.
                if ((ivRecoveryIdKnown == false) || (ivRecoveryId == 0)) //d194602
                {
                    if (ivEnlistNotNeeded == false)
                    {
                        if (RecoverableXAResourceAccessor.isRecoverableXAResource(xaResource)) //d197017
                        {
                            recoverableXAResource = true;
                        }
                        else
                        {
                            // CNTR0082E: Can not enlist XAResource since recovery ID for
                            // resource adapter {0} for MDB {1} is not known.
                            Tr.error(tc, "ENDPOINT_RECOVERY_ID_UNKNOWN_CNTR0082E",
                                     ivRAKey, beanMetaData.j2eeName);
                            throw new UnavailableException("setRecoveryId must be called prior to createEndpoint");
                        }
                    }
                }
            }

            if (ivState == ACTIVE_STATE)
            {
                if (!isEndpointActive()) //d450478
                {
                    // This can happen when RALifeCycleManager forcefully deactivates an
                    // endpoint during an RA stop operation. See the
                    // messageEndpointForcefullyDeactivated method in this class.
                    throw new UnavailableException("endpoint needs to be activated.");
                }

                // Use pool only if one was created.
                if (ivInvocationHandlerPool != null) // d423445.1
                {
                    // LI2110.56 start of change.
                    // Endpoint is active, so proceed with creating the endpoint.
                    // First see if one is available in the free pool.
                    endpoint = (MessageEndpointBase) ivInvocationHandlerPool.get();
                    if (endpoint == null)
                    {
                        // Free pool empty, so check whether it okay to create a new one.
                        // f743-7046 start
                        if (ivNumberOfMessageEndpointsCreated < ivMaxCreation) //LI2110.56
                        {
                            // Limit was NOT reached, so just increment count of created endpoints.
                            ++ivNumberOfMessageEndpointsCreated;
                            newInstanceRequired = true;
                        }
                        else
                        {
                            // Max creation limit reached. Was a valid wait timeout value provided?
                            if (timeout <= 0)
                            {
                                if (majorJCAVersion == 1 && minorJCAVersion == 5)
                                {
                                    // JCA 1.5 RA does not provide a timeout value, so throw same exceptions
                                    // we have always thrown in past to ensure same behavior.  //PM16610
                                    throw new UnavailableException("limit for number of MessageEndpoint proxies reached. Limit = " + ivMaxCreation);
                                }
                                else
                                {
                                    // JCA 1.6 or later RA did not provide a valid wait timeout value, so throw the
                                    // retryable exception immediately.  //PM16610
                                    throw new RetryableUnavailableException("limit for number of MessageEndpoint proxies reached.  Limit = " + ivMaxCreation);
                                }
                            }
                            else
                            {
                                // A valid wait timeout value was provided, so it must be JCA 1.6 or later.
                                // Wait for some thread to call MessageEndpoint.release() method. When that happens
                                // the returnInvocationHandler method in this class is called and it will notify this
                                // thread that it can proceed with the create.
                                try
                                {
                                    ivStateLock.wait(timeout);
                                } catch (InterruptedException e)
                                {
                                    //FFDCFilter.processException(e, CLASS_NAME + ".createEndpoint", "519", this);
                                }

                                // Determine whether wait timeout or release occurred. If release occurred,
                                // then a handler will be retrieved from the pool.
                                endpoint = (MessageEndpointBase) ivInvocationHandlerPool.get();
                                if (endpoint == null)
                                {
                                    // Timed out waiting for a proxy to be released.
                                    throw new RetryableUnavailableException("timed out waiting for a MessageEndpoint proxy to become available.");
                                }
                                else
                                {
                                    // A MessageEndpoint proxy is now available. Ensure deactivate did not
                                    // occur while waiting for a MessageEndpoint to be released.
                                    if (ivState == ACTIVE_STATE)
                                    {
                                        // Still active and there is at least 1 MessageEndpoint proxy available.
                                        // handler was retrieved from the pool.  No need to create a new one.
                                        newInstanceRequired = false;
                                    }
                                    else if ((ivState == DEACTIVATING_STATE) || (ivState == DEACTIVATE_PENDING_STATE)) //d450478
                                    {
                                        throw new UnavailableException("deactivate of endpoint is in progress.");
                                    }
                                    else
                                    {
                                        throw new UnavailableException("endpoint needs to be activated.");
                                    }
                                }
                            }
                        } // f743-7046 end of change.
                    } // LI2110.56 end of change.
                }
            }
            else if (ivState == ACTIVATING_STATE)
            {
                // Endpoint is activating, so check if calling thread is the activating thread.
                if (ivActivatingThread == Thread.currentThread())
                {
                    // Calling thread is the activating thread, so throw
                    // exception since we can not block the activating thread and
                    // it is not retryable from this thread.
                    throw new UnavailableException("activating thread not allowed to create endpoint during activation.");
                }
                else
                {
                    // Not the activation thread, so block this thread until the activate completes.
                    try
                    {
                        if (timeout > 0) // f743-7046 start
                        {
                            ivStateLock.wait(timeout);
                        }
                        else
                        {
                            ivStateLock.wait();
                        } // f743-7046 end
                    } catch (InterruptedException i)
                    {
                        //FFDCFilter.processException(e, CLASS_NAME + ".createEndpoint", "406", this);
                    }

                    // Now verify activate was successful.
                    if (ivState != ACTIVE_STATE)
                    {
                        if (ivState == ACTIVATING_STATE) // f743-7046 start
                        {
                            // This can only happen if a JCA 1.6 or later RA provided a timeout value.
                            // So throw the retryable exception immediately.
                            throw new RetryableUnavailableException("timed out while waiting for activation to complete.");
                        }
                        else
                        {
                            // Neither in active nor activating state, so a deactivate must have occurred.
                            // This is not a transient condition, so throw non retryable exception.
                            throw new UnavailableException("endpoint needs to be activated.");
                        } // f743-7046 end
                    }
                }
            }
            else if ((ivState == DEACTIVATING_STATE) || (ivState == DEACTIVATE_PENDING_STATE)) //d450478
            {
                throw new UnavailableException("deactivate of endpoint is in progress.");
            }
            else
            {
                throw new UnavailableException("endpoint needs to be activated.");
            }
        }
        // d197017 ends

        // Create MessageEndpoint Proxy object using the Constructor Method that
        // was cached by the initialize method of this object.
        UnavailableException ex = null;
        try
        {
            // Was above code able to get a MessageEndpointHandler
            // from the free pool?
            if (endpoint != null)
            {
                // Yes, so get proxy object from the MessageEndpointHandler
                // object obtained from free pool.
                proxy = endpoint.ivProxy;
            }
            else
            {
                // Nope, so free pool must have been empty.  Since we got this
                // far, we know creation counter was incremented and newInstanceRequired
                // flag should have been set by above code.  So go ahead and try
                // to create a new instance.  Exception handler code below will decrement
                // counter if something goes wrong in the creation.
                proxy = beanMetaData.localImplClass.newInstance();

                // For no-method interface MDB, the 'proxy' will not
                // subclass MessageEndpointBase, but the MDB itself, so a separate
                // MessageEndpointBase must be created to hold the metadata and
                // associated with the real proxy.
                if (beanMetaData.ivIsNoMethodInterfaceMDB)
                {
                    endpoint = new MessageEndpointBase();
                    // Set the ivMessageEndpointBase on the generated proxy.
                    beanMetaData.ivMessageEndpointBaseField.set(proxy, endpoint);
                }
                // Otherwise, normal proxy - subclasses MessageEndpointBase
                else
                {
                    endpoint = (MessageEndpointBase) proxy;
                }

                MessageEndpointBase.construct(this,
                                              endpoint,
                                              ivRecoveryId,
                                              container,
                                              beanMetaData,
                                              pmiBean,
                                              wrapperManager,
                                              ivRRSTransactional);
                endpoint.ivProxy = proxy;
            }

            // Initialize InvocationHandler to be owner of this
            // proxy object and XAResource and determine if enlistment
            // of a XAResource is needed.
            if (ivEnlistNotNeeded)
            {
                if (xaResource == null)
                {
                    // Enlistment is not needed and no XAResource
                    // was passed by RA.  So everything is fine.
                    MessageEndpointBase.initialize(endpoint, null, false, majorJCAVersion, minorJCAVersion); // f743-7046
                }
                else
                {
                    // Enlistment is not needed, but the RA did pass an XAResource object.
                    // We need to throw an exception since transaction recovery setup was
                    // not completed successfully for this RA.
                    ex = mapAndLogTranEnlistmentNotNeeded();
                }
            }
            else
            {
                // Transaction recovery is setup for this RA, so
                // use whatever the RA passed as an XAResource.
                MessageEndpointBase.initialize(endpoint, xaResource, recoverableXAResource, majorJCAVersion, minorJCAVersion); // f743-7046
            }
        } catch (Throwable t)
        {
            // CNTR0083E: Creation of a message endpoint failed: \n {0}
            Tr.error(tc, "CREATE_ENDPOINT_FAILED_CNTR0083E", t);
            ex = new UnavailableException("Creation of MessageEndpoint Proxy failed", t);
        }

        // Check whether exception needs to be thrown.
        // If so, return invocation handler to pool if necessary
        // and throw the exception.
        if (ex != null)
        {
            // Use pool only if one was created.
            if (ivInvocationHandlerPool != null) // d423445.1
            {
                // Since proxy not being returned to caller,
                // Return InvocationHandler to the pool if both MessageEndpointHandler
                // and proxy object was created prior to the exception.
                if (endpoint != null && proxy != null) // LI2110.56
                {
                    MessageEndpointBase.reset(endpoint); // F73236 PooledObject removed, call reset() directly
                    ivInvocationHandlerPool.put(endpoint);
                }
                else
                {
                    // LI2110.56 beginning of change.
                    // Decrement creation counter so that it is not off by 1 as
                    // a result of a failure during creation of either MessageEndpointHandler
                    // or the proxy object itself (e.g. out of memory exception).
                    if (newInstanceRequired)
                    {
                        synchronized (ivStateLock)
                        {
                            --ivNumberOfMessageEndpointsCreated;
                        }
                    } // LI2110.56 end of change.
                }
            }

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            {
                BeanMetaData bmd = super.beanMetaData;
                Tr.exit(tc, "createEndpoint for enterprise class " + bmd.enterpriseBeanName + " failed.");
            }

            // Now throw the UnavailableException
            throw ex;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            Tr.exit(tc, "MEF.createEndpoint for enterprise class " + beanMetaData.enterpriseBeanName);
        }

        return (MessageEndpoint) proxy;
    }
933265
function (elInfo, p, dropOptions, isSource, isTarget) {
			var proxyComponent = new jsPlumbUIComponent(p);
			var _drop = p._jsPlumb.EndpointDropHandler({
				jsPlumb: _currentInstance,
				enabled: function () {
					return elInfo.def.enabled;
				},
				isFull: function () {
					var targetCount = _currentInstance.select({target: elInfo.id}).length;
					return elInfo.def.maxConnections > 0 && targetCount >= elInfo.def.maxConnections;
				},
				element: elInfo.el,
				elementId: elInfo.id,
				isSource: isSource,
				isTarget: isTarget,
				addClass: function (clazz) {
					_currentInstance.addClass(elInfo.el, clazz);
				},
				removeClass: function (clazz) {
					_currentInstance.removeClass(elInfo.el, clazz);
				},
				onDrop: function (jpc) {
					var source = jpc.endpoints[0];
					source.anchor.locked = false;
				},
				isDropAllowed: function () {
					return proxyComponent.isDropAllowed.apply(proxyComponent, arguments);
				},
				isRedrop:function(jpc) {
					return (jpc.suspendedElement != null && jpc.suspendedEndpoint != null && jpc.suspendedEndpoint.element === elInfo.el);
				},
				getEndpoint: function (jpc) {

					// make a new Endpoint for the target, or get it from the cache if uniqueEndpoint
					// is set. if its a redrop the new endpoint will be immediately cleaned up.

					var newEndpoint = elInfo.def.endpoint;

					// if no cached endpoint, or there was one but it has been cleaned up
					// (ie. detached), create a new one
					if (newEndpoint == null || newEndpoint._jsPlumb == null) {
						var eps = _currentInstance.deriveEndpointAndAnchorSpec(jpc.getType().join(" "), true);
						var pp = eps.endpoints ? jsPlumb.extend(p, {
							endpoint:elInfo.def.def.endpoint || eps.endpoints[1]
						}) :p;
						if (eps.anchors) {
							pp = jsPlumb.extend(pp, {
								anchor:elInfo.def.def.anchor || eps.anchors[1]
							});
						}
						newEndpoint = _currentInstance.addEndpoint(elInfo.el, pp);
						newEndpoint._mtNew = true;
					}

					if (p.uniqueEndpoint) elInfo.def.endpoint = newEndpoint;  // may of course just store what it just pulled out. that's ok.
					// TODO test options to makeTarget to see if we should do this?
					newEndpoint._doNotDeleteOnDetach = false; // reset.
					newEndpoint._deleteOnDetach = true;

					// if connection is detachable, init the new endpoint to be draggable, to support that happening.
					if (jpc.isDetachable())
						newEndpoint.initDraggable();

					// if the anchor has a 'positionFinder' set, then delegate to that function to find
					// out where to locate the anchor.
					if (newEndpoint.anchor.positionFinder != null) {
						var dropPosition = _currentInstance.getUIPosition(arguments, _currentInstance.getZoom()),
							elPosition = _currentInstance.getOffset(elInfo.el),
							elSize = _currentInstance.getSize(elInfo.el),
							ap = newEndpoint.anchor.positionFinder(dropPosition, elPosition, elSize, newEndpoint.anchor.constructorParams);

						newEndpoint.anchor.x = ap[0];
						newEndpoint.anchor.y = ap[1];
						// now figure an orientation for it..kind of hard to know what to do actually. probably the best thing i can do is to
						// support specifying an orientation in the anchor's spec. if one is not supplied then i will make the orientation
						// be what will cause the most natural link to the source: it will be pointing at the source, but it needs to be
						// specified in one axis only, and so how to make that choice? i think i will use whichever axis is the one in which
						// the target is furthest away from the source.
					}

					return newEndpoint;
				},
				maybeCleanup: function (ep) {
					if (ep._mtNew && ep.connections.length === 0) {
						_currentInstance.deleteObject({endpoint: ep});
					}
					else
						delete ep._mtNew;
				}
			});

			// wrap drop events as needed and initialise droppable
			var dropEvent = jsPlumb.dragEvents.drop;
			dropOptions.scope = dropOptions.scope || (p.scope || _currentInstance.Defaults.Scope);
			dropOptions[dropEvent] = _ju.wrap(dropOptions[dropEvent], _drop, true);

			// if target, return true from the over event. this will cause katavorio to stop setting drops to hover
			// if multipleDrop is set to false.
			if (isTarget) {
				dropOptions[jsPlumb.dragEvents.over] = function () { return true; };
			}

			// vanilla jsplumb only
			if (p.allowLoopback === false) {
				dropOptions.canDrop = function (_drag) {
					var de = _drag.getDragElement()._jsPlumbRelatedElement;
					return de != elInfo.el;
				};
			}
			_currentInstance.initDroppable(elInfo.el, dropOptions, "internal");

			return _drop;

		}
1336009
protected TimeoutId requestTimeout(final long delay, final TimeUnit unit) {
        return requestTimeout(delay, unit, null, null);
    }
360863
@Override
    public CompletableFuture<Void> createSegment(@NonNull String segmentName, Duration timeout) {
        Exceptions.checkNotClosed(this.closed.get(), this);
        val attributes = TableAttributes.DEFAULT_VALUES
                .entrySet().stream()
                .map(e -> new AttributeUpdate(e.getKey(), AttributeUpdateType.None, e.getValue()))
                .collect(Collectors.toList());
        return this.segmentContainer.createStreamSegment(segmentName, attributes, timeout);
    }
1084425
function timeout(message) {
    $log.warn('Plugin client request timeout: ' + serialize(message));

    var promiseIndex = lodash.findIndex(promises, function(promise) {
      return promise.id == message.header.id;
    });

    if (promiseIndex >= 0) {
      var promise = lodash.pullAt(promises, promiseIndex);

      message.response = {
        statusCode: 408,
        statusText: 'REQUEST_TIMED_OUT',
        data: {
          message: 'Request timed out.'
        }
      }
      promise[0].onComplete(message);
    } else {
      $log.warn('Message request timed out but there is no promise to fulfill: ' + serialize(message));
    }
  }
611897
@Override
    public Configuration defaultTimeout(long time, TimeUnit unit) {
        return defaultTimeout(new Duration(time, unit));
    }
448095
public long waiting(long timeout, boolean modifyTimeout)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "waiting", new Object[] { new Long(timeout),  Boolean.valueOf(modifyTimeout) });

    boolean processGets = true;
    synchronized(this)
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        SibTr.debug(tc, "refilling: " + Boolean.valueOf(isRefilling) +
                        "doRefill: " + Boolean.valueOf(doRefill));
      if (isRefilling)
      {
        processGets = false;
        
        // A request came in while we were busy doing refills. Therfore we
        // record the timeout (if we dont have a longer one) in case we have to redrive
        // a new refill request when the current one is satisfied.
        if (timeout == LocalConsumerPoint.INFINITE_WAIT)
          refillTime = timeout;
        else if (timeout != LocalConsumerPoint.NO_WAIT)
        {
          // Work out when this request would have expired
          long expiryTime = System.currentTimeMillis() + timeout;
          
          // If we dont have a current refillTime that extends to the period of this request
          // then set the new refillTime
          if (refillTime != LocalConsumerPoint.INFINITE_WAIT && refillTime < expiryTime)
            refillTime = expiryTime;
        }
      }
      else
      {
        if (doRefill) // Has a refill been inititated
        {
          isRefilling = true;
          doRefill = false;
        }
      }        
    }
    
    if (processGets)
    {     
      try
      {
        long protocolTimeout;
        // Either modify the timeout with a roundTrip time or not.
        // But always convert the protocol time into a SIMP format
        // (from the LCP format)
        if (modifyTimeout)
        {
          if (timeout == LocalConsumerPoint.INFINITE_WAIT)
          { // no need to modify timeout
    
            // we are using a different constant for the protocol
            protocolTimeout = SIMPConstants.INFINITE_TIMEOUT;
          }
          else if (timeout == LocalConsumerPoint.NO_WAIT)
          {
            timeout = getRoundTripTime(); // the consumer needs to wait atleast
                                          // for this time
            protocolTimeout = 0L; // this ensures that the DME knows not to wait
          }
          else
          {
            long rtt = getRoundTripTime();
            protocolTimeout = timeout + rtt;
            timeout = protocolTimeout;
          }
        }
        else
        {
          if (timeout == LocalConsumerPoint.INFINITE_WAIT)
            protocolTimeout = SIMPConstants.INFINITE_TIMEOUT;
          else if (timeout == LocalConsumerPoint.NO_WAIT)
            protocolTimeout = 0L; // this ensures that the DME knows not to wait
          else
            protocolTimeout = timeout;
        }
        
        boolean callIssueGet = true;
        if (readAhead || protocolTimeout == SIMPConstants.INFINITE_TIMEOUT)
        {
          synchronized (this)
          {
            if (countOfOutstandingInfiniteTimeoutGets > 0)
            {
              callIssueGet = false; // already scheduled requests
            }
            else
            {
              if (keyGroup == null)
              {
  
                // will issue get, so update counts within the synchronized block
                if (protocolTimeout == SIMPConstants.INFINITE_TIMEOUT)
                {
                  countOfOutstandingInfiniteTimeoutGets++;
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "readAhead change: countOfOutstandingInfiniteTimeoutGets++ " + countOfOutstandingInfiniteTimeoutGets);
                }
              }
              // else do nothing, since gets issued on the key group don't count
              // towards
              // countOfOutstandingInfiniteTimeoutGets
            }
          }
          if (readAhead)
              tryPrefetching(); // call try prefetching since window may have
                                // increased
        }
  
        if (callIssueGet)
        {
          AIStreamKey key;
          if (keyGroup == null)
            key = rcd.issueGet(criteria, protocolTimeout, this, this);
          else
            key = ((RemoteQPConsumerKeyGroup) keyGroup).issueGet(protocolTimeout, this);
         
          if (key == null)
          {
            // decrement the counts. this will be very rare!
            synchronized (this)
            {
              if ((keyGroup == null)
                  && (protocolTimeout == SIMPConstants.INFINITE_TIMEOUT))
              {
                countOfOutstandingInfiniteTimeoutGets--;
                
  
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "readAhead change: countOfOutstandingInfiniteTimeoutGets-- " + countOfOutstandingInfiniteTimeoutGets);
              }
            }
            // log and throw exception to consumer
            SIResourceException e = new SIResourceException(nls
                .getFormattedMessage("ANYCAST_STREAM_UNAVAILABLE_CWSIP0481",
                    new Object[] { rcd.getDestName(),
                        rcd.getLocalisationUuid().toString() }, null));
            FFDCFilter.processException(e,
                "com.ibm.ws.sib.processor.impl.RemoteQPConsumerKey.waiting",
                "1:357:1.47.1.26", this);
            SibTr.exception(tc, e);
  
            consumerPoint.notifyException(e);
          }
        }
      }
      catch (SIResourceException e)
      {
        // FFDC
        FFDCFilter.processException(e,
            "com.ibm.ws.sib.processor.impl.RemoteQPConsumerKey.waiting",
            "1:369:1.47.1.26", this);
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
          SibTr.exception(tc, e);
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
          SibTr.exit(tc, "waiting", "SIErrorException");
        throw new SIErrorException(e);
      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(this, tc, "waiting", Long.valueOf(timeout));

    return timeout;
  }
27440
public static void addLast(ChannelPipeline pipeline, long timeout, TimeUnit unit, BasicCounter httpRequestReadTimeoutCounter)
    {
        HttpRequestReadTimeoutHandler handler = new HttpRequestReadTimeoutHandler(timeout, unit, httpRequestReadTimeoutCounter);
        pipeline.addLast(HANDLER_NAME, handler);
    }
1227067
public void modifyOptions(Map<String, Object> options) throws ProvisioningApiException {
        try {

            OptionsPostResponseStatusSuccess resp = optionsApi.optionsPost(new OptionsPost().data(new OptionsPostData().options(options)));

            if (!resp.getStatus().getCode().equals(0)) {
                throw new ProvisioningApiException("Error modifying options. Code: " + resp.getStatus().getCode());
            }

        } catch (ApiException e) {
            throw new ProvisioningApiException("Error modifying options", e);
        }
    }
305849
def code=(code)
      validator = EnumAttributeValidator.new('String', ["Continue", "SwitchingProtocols", "OK", "Created", "Accepted", "NonAuthoritativeInformation", "NoContent", "ResetContent", "PartialContent", "MultipleChoices", "Ambiguous", "MovedPermanently", "Moved", "Found", "Redirect", "SeeOther", "RedirectMethod", "NotModified", "UseProxy", "Unused", "TemporaryRedirect", "RedirectKeepVerb", "BadRequest", "Unauthorized", "PaymentRequired", "Forbidden", "NotFound", "MethodNotAllowed", "NotAcceptable", "ProxyAuthenticationRequired", "RequestTimeout", "Conflict", "Gone", "LengthRequired", "PreconditionFailed", "RequestEntityTooLarge", "RequestUriTooLong", "UnsupportedMediaType", "RequestedRangeNotSatisfiable", "ExpectationFailed", "UpgradeRequired", "InternalServerError", "NotImplemented", "BadGateway", "ServiceUnavailable", "GatewayTimeout", "HttpVersionNotSupported"])
      if code.to_i == 0
        unless validator.valid?(code)
          raise ArgumentError, "invalid value for 'code', must be one of #{validator.allowable_values}."
        end
        @code = code
      else
        @code = validator.allowable_values[code.to_i]
      end
    end
145009
public static Function<RSocket, RSocket> timeout(Duration timeout) {
    return source ->
        new RSocketProxy(source) {
          @Override
          public Mono<Void> fireAndForget(Payload payload) {
            return source.fireAndForget(payload).timeout(timeout);
          }

          @Override
          public Mono<Payload> requestResponse(Payload payload) {
            return source.requestResponse(payload).timeout(timeout);
          }

          @Override
          public Flux<Payload> requestStream(Payload payload) {
            return source.requestStream(payload).timeout(timeout);
          }

          @Override
          public Flux<Payload> requestChannel(Publisher<Payload> payloads) {
            return source.requestChannel(payloads).timeout(timeout);
          }

          @Override
          public Mono<Void> metadataPush(Payload payload) {
            return source.metadataPush(payload).timeout(timeout);
          }
        };
  }
1095464
@Override
    public void unregisterEndpoint(QName serviceName, String endpointURL)
            throws ServiceLocatorFault, InterruptedExceptionFault {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("Unregistering endpoint " + endpointURL + " for service "
                    + serviceName + "...");
        }
        try {
            initLocator();
            locatorClient.unregister(serviceName, endpointURL);
        } catch (ServiceLocatorException e) {
            ServiceLocatorFaultDetail serviceFaultDetail = new ServiceLocatorFaultDetail();
            serviceFaultDetail.setLocatorFaultDetail(serviceName.toString()
                    + "throws ServiceLocatorFault");
            throw new ServiceLocatorFault(e.getMessage(), serviceFaultDetail);
        } catch (InterruptedException e) {
            InterruptionFaultDetail interruptionFaultDetail = new InterruptionFaultDetail();
            interruptionFaultDetail.setInterruptionDetail(serviceName
                    .toString() + "throws InterruptionFault");
            throw new InterruptedExceptionFault(e.getMessage(),
                    interruptionFaultDetail);
        }
    }
328033
void endIfStarted(CodeAttribute b, ClassMethod method) {
        b.aload(getLocalVariableIndex(0));
        b.dup();
        final BranchEnd ifnotnull = b.ifnull();
        b.checkcast(Stack.class);
        b.invokevirtual(Stack.class.getName(), END_INTERCEPTOR_CONTEXT_METHOD_NAME, EMPTY_PARENTHESES + VOID_CLASS_DESCRIPTOR);
        BranchEnd ifnull = b.gotoInstruction();
        b.branchEnd(ifnotnull);
        b.pop(); // remove null Stack
        b.branchEnd(ifnull);
    }
136853
@Override
    public void removeEndPoint(String name) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Deleting endpoint: " + name);
        }

        synchronized (this.endpoints) {
            if (this.endpoints.remove(name) != null) {
                unregisterMBeanInService(name);
            }
        }
    }
283401
public void setTimeout(int timeout) {
        this.timeout = timeout;



        httpClient.connectTimeout(timeout, TimeUnit.MILLISECONDS);
        httpClient.readTimeout(timeout, TimeUnit.MILLISECONDS);
        httpClient.writeTimeout(timeout, TimeUnit.MILLISECONDS);

    }
494574
@Override
    public void setStatusCode(StatusCodes code) {

        if (!code.equals(this.myStatusCode)) {
            this.myStatusCode = code;
            // no matter what, empty out the reason phrase information so that it
            // will default to match this new status code
            this.myReason = null;
            this.myReasonBytes = null;
            super.setFirstLineChanged();
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "setStatusCode(sc): " + code);
        }
    }
687545
function createTimeout(errorCallback, timeout) {
    var t = setTimeout(function() {
        clearTimeout(t);
        t = null;
        errorCallback({
            code:PositionError.TIMEOUT,
            message:"Position retrieval timed out."
        });
    }, timeout);
    return t;
}