Check whether a particular request is expecting continue.
@param inboundRequestMsg in question
@return true if the request expects 100-continue response
165993
public static boolean is100ContinueRequest(HttpCarbonMessage inboundRequestMsg) {
        return HEADER_VAL_100_CONTINUE.equalsIgnoreCase(
                inboundRequestMsg.getHeader(HttpHeaderNames.EXPECT.toString()));
    }
73165
protected boolean maxRequestsServed() {
        // PK12235, check for a partial or full stop
        if (getChannel().isStopping()) {
            // channel has stopped, no more keep-alives
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Channel stopped, disabling keep-alive request");
            }
            return true;
        }
        if (!getChannel().getHttpConfig().isKeepAliveEnabled()) {
            // keep alives are disabled, no need to check the max request number
            return true;
        }
        int max = getChannel().getHttpConfig().getMaximumPersistentRequests();
        // -1 is unlimited, 0..1 is 1 request, any above that is that exact
        // number of requests
        if (0 <= max) {
            return (this.numRequestsProcessed >= max);
        }
        return false;
    }
96932
public boolean isAccepted(IRequestInfo req) {
        boolean answer = true;
        if (processAll) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "processAll is true, therefore we always intercept.");
            }
            return answer;
        }

        String HTTPheader = null;

        Iterator<ICondition> iter = filterCondition.iterator();
        while (iter.hasNext()) {
            ICondition cond = iter.next();
            String key = cond.getKey();

            // Start with request header attribute name
            HTTPheader = req.getHeader(key);

            boolean ipAddress = false;

            // The header argument is a null, so go through other tags.
            if (HTTPheader == null) {
                if (key.equals(REMOTE_ADDRESS)) {
                    HTTPheader = req.getRemoteAddr();
                    ipAddress = true;
                } else if (key.equals(REQUEST_URL)) {
                    HTTPheader = req.getRequestURL();
                } else if (key.equals(AuthFilterConfig.KEY_WEB_APP) || key.equals(APPLICATION_NAMES)) {
                    HTTPheader = req.getApplicationName();
                } else if (key.equals(AuthFilterConfig.KEY_COOKIE)) {
                    HTTPheader = req.getCookieName(key);
                } else if (cond instanceof NotContainsCondition) {
                    continue;
                } else {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                        Tr.debug(tc, "No HTTPheader found, and no remote-address, request-url, webApp, applicationNames, cookie, or requestHeader rule used - do not Intercept.");
                    }
                    return false; // if no header found, the condition fails
                }
            }
            if (HTTPheader == null) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "No HTTPheader found - do not Intercept.");
                }
                return false; // if no header found, the condition fails
            }

            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Checking condition {0} {1}.", new Object[] { cond, HTTPheader });
            }
            try {
                IValue compareValue;
                if (ipAddress) {
                    compareValue = new ValueIPAddress(HTTPheader);
                } else {
                    compareValue = new ValueString(HTTPheader);
                }
                answer = cond.checkCondition(compareValue);
                if (!answer) {
                    break;
                }

            } catch (FilterException e) {
                throw new RuntimeException(e);
            }
        }
        return answer;
    }
129823
public boolean writeInbound(Object... msgs) {
        ensureOpen();
        if (msgs.length == 0) {
            return isNotEmpty(inboundMessages);
        }

        ChannelPipeline p = pipeline();
        for (Object m: msgs) {
            p.fireChannelRead(m);
        }

        flushInbound(false, voidPromise());
        return isNotEmpty(inboundMessages);
    }
594456
public boolean hasMoreMessages() {
    if (!rqueue.isEmpty()) {
      return true;
    } else {
      synchronized (omap) {
        Iterator<TapStream> itr = omap.keySet().iterator();
        while (itr.hasNext()) {
          TapStream ts = itr.next();
          if (ts.isCompleted() || ts.isCancelled() || ts.hasErrored()) {
            omap.get(ts).shutdown();
            omap.remove(ts);
          }
        }
        if (omap.size() > 0) {
          return true;
        }
      }
    }
    return false;
  }
655057
private boolean shouldMessageBeProcessed(DiscoveryIncomingMessage pMsg) {
        return pMsg != null &&
               restrictor.isRemoteAccessAllowed(pMsg.getSourceAddress().getHostAddress())
               && pMsg.isQuery();
    }
91589
protected boolean containsRel100(Message message) {
		ListIterator<SIPHeader> requireHeaders = message.getHeaders(RequireHeader.NAME);
		if(requireHeaders != null) {
			while (requireHeaders.hasNext()) {
				if(REL100_OPTION_TAG.equals(requireHeaders.next().getValue())) {
					return true;
				}
			}
		}
		ListIterator<SIPHeader> supportedHeaders = message.getHeaders(SupportedHeader.NAME);
		if(supportedHeaders != null) {
			while (supportedHeaders.hasNext()) {
				if(REL100_OPTION_TAG.equals(supportedHeaders.next().getValue())) {
					return true;
				}
			}
		}
		return false;
	}
438184
protected void incrementRequestCount(ResourceType type, int delta) {
    Context c = getContext(type);
    int newRequestCount = c.requestCount + delta;
    c.requestCount = newRequestCount;
    if (newRequestCount > c.maxConcurrentRequestCount) {
      c.maxConcurrentRequestCount = newRequestCount;
    }
  }
1178851
@Override
    public boolean hasRemaining() {
        if (isFCEnabled()) {
            int remaining = this.fcLimit - position();
            if (remaining < 0) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "hasRmeaining, less than 0");
                }
                RuntimeException rte = new RuntimeException("FCWsByteBufferImpl.hasRemaining(): value is less than 0");
                FFDCFilter.processException(rte, CLASS_NAME + ".hasRemaining()", "1115", this);
                throw rte;
            }
            return (remaining > 0);
        }
        return super.hasRemaining();
    }
469591
@Override
  public boolean acceptInboundMessage(final Object msg) throws Exception {
    if (!(msg instanceof FullHttpRequest))
      return false;

    final FullHttpRequest request = (FullHttpRequest) msg;
    final String uri = request.getUri();
    return pathResolver.isStaticPath(uri);
  }
1087481
private boolean checkLongPollingOrder(HttpAcceptSession session) {
        if (firstWriter && !validateSequenceNo && longpoll(session)) {
            String message = "Out of order long-polling request, must not be first";
            setCloseException(new IOException(message));
            HttpStatus status = HttpStatus.CLIENT_BAD_REQUEST;
            session.setStatus(status);
            session.setWriteHeader(HEADER_CONTENT_LENGTH, "0");
            session.close(true);
            return false;
        }
        return true;
    }
1070256
@Override
	public boolean hasMoreElements()
	{
		if (endOfQueueReached)
			return false;
		try
		{
			checkNotClosed();
			Message msg = fetchNext();
			return msg != null;
		}
		catch (JMSException e)
		{
			throw new IllegalStateException(e.toString());
		}
	}
1316389
private static boolean checkRequestAmount(WireRequest request) {
    boolean sufficientBalance = request.getAmount() < MAX_ALLOWABLE_AMOUNT;

    if (!sufficientBalance) {
      LOG.warning(
          String.format("Rejected excessive request of $%d",
              request.getAmount()));
    }

    return sufficientBalance;
  }
1278646
public boolean hasValidKey(HttpMessage msg) {
		try {
			HttpRequestHeader requestHeader = msg.getRequestHeader();
			return this.hasValidKey(requestHeader, getParams(requestHeader));
		} catch (ApiException e) {
			logger.error(e.getMessage(), e);
			return false;
		}
	}
347836
public void incrementWaitingRequests(String browserName) {
        logger.entering(browserName);
        validateBrowserName(browserName);
        BrowserStatistics lStatistics = createStatisticsIfNotPresent(browserName);
        lStatistics.incrementWaitingRequests();
        logger.exiting();
    }
735195
private synchronized boolean msgCanBeSent( long stamp, boolean nackMsg )
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "msgCanBeSent", new Object[] { Long.valueOf(stamp),
          Boolean.valueOf(nackMsg),
          Long.valueOf(firstMsgOutsideWindow),
          Boolean.valueOf(containsGuesses)});

    boolean sendMessage = true;
    
    // Check whether we can send the message
    // Don't send any messages once there is a guess in the stream (unless a NACK)
    if ((stamp >= firstMsgOutsideWindow) || (containsGuesses && !nackMsg))
    {
      sendMessage = false;
      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
      {
        SibTr.debug(tc, "firstMsgOutsideWindow is: " + firstMsgOutsideWindow
        + " sendWindow is " +  sendWindow + " containsGuesses is " + containsGuesses);
      }
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "msgCanBeSent", Boolean.valueOf(sendMessage));

    return sendMessage;
  }
768562
private boolean hasMessageBody() throws IOException {
    int statusCode = getStatusCode();
    if (getRequest().getRequestMethod().equals(HttpMethods.HEAD)
        || statusCode / 100 == 1
        || statusCode == HttpStatusCodes.STATUS_CODE_NO_CONTENT
        || statusCode == HttpStatusCodes.STATUS_CODE_NOT_MODIFIED) {
      ignore();
      return false;
    }
    return true;
  }