docs: public int discriminate(VirtualConnection vc, Object discrimData) {
  
          // PK12235, check for a full stop only
          if (isStopped()) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "Channel stopped, ignoring discriminate on: " + vc);
              }
              return Discriminator.NO;
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "Discriminating against " + vc + " with " + discrimData);
          }
          // we take the WsByteBuffer class but the TCP channel actually
          // gives us an array of those
          WsByteBuffer[] buffs = (WsByteBuffer[]) discrimData;
  
          // if there's no data to read, we can't continue now but we can't
          // rule it out that it might be ours
          if (null == buffs || 0 == buffs.length) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "No data provided, returning MAYBE");
              }
              return Discriminator.MAYBE;
          }
          HttpInboundLink link = (HttpInboundLink) vc.getStateMap().get(CallbackIDs.CALLBACK_HTTPICL);
          if (null == link) {
              // brand new connection
              link = new HttpInboundLink(this, vc);
          } else {
              link.init(vc, this);
          }
          // either way, pull the SC from the link object now
          HttpInboundServiceContextImpl mySvcCtxt = (HttpInboundServiceContextImpl) link.getChannelAccessor();
          boolean retVal = false;
  
          // check through each buffer provided. Stop when we know that
          // either this is ours, not ours, or we've run out of data
  
          for (int i = 0; i < buffs.length && null != buffs[i]; i++) {
  
              // pull off the next buffer to parse through
              WsByteBuffer buff = buffs[i];
              int limit = buff.limit();
              int position = buff.position();
              // have the SC reset this read buffer depending on how many times
              // we've been through discrimination with it.
              mySvcCtxt.enableBufferModification();
              mySvcCtxt.configurePostReadBuffer(buff);
  
              try {
                  // parse the first line only to determine if this is
                  // an HTTP message
                  retVal = mySvcCtxt.getRequestImpl().parseLineDiscrim(buff);
              } catch (MalformedMessageException mme) {
                  // no FFDC required
                  // if we received this, then the section throwing the exception
                  // will have logged in debug what was wrong, or what was not
                  // HTTP about this request
                  buff.limit(limit);
                  buff.position(position);
                  link.destroy(null);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Discriminate returning NO for non-HTTP msg");
                  }
                  return Discriminator.NO;
              } catch (Exception e) {
                  // no FFDC required
                  // any other exception indicates an error in the code when
                  // trying to parse...
                  buff.limit(limit);
                  buff.position(position);
                  link.destroy(null);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Unexpected exception [" + e + "]");
                      Tr.debug(tc, "Discriminate returning NO");
                  }
                  return Discriminator.NO;
              }
              // save where we stopped (for MAYBE and YES both)
              mySvcCtxt.setOldLimit(buff.limit());
              if (retVal) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Discrimination returning YES");
                  }
                  // save this link object in the VC
                  vc.getStateMap().put(CallbackIDs.CALLBACK_HTTPICL, link);
                  return Discriminator.YES;
              }
              // need more data case, reset the buffer
              buff.limit(limit);
              buff.position(position);
          }
  
          // save this link object in the VC in case it does come back to us
          vc.getStateMap().put(CallbackIDs.CALLBACK_HTTPICL, link);
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "Returning MAYBE for " + vc);
          }
          return Discriminator.MAYBE;
      }