<p>
The protocol of network-related information about a finding.
</p>

@param networkProtocol
The protocol of network-related information about a finding.
423939
public void setNetworkProtocol(java.util.Collection<StringFilter> networkProtocol) {
        if (networkProtocol == null) {
            this.networkProtocol = null;
            return;
        }

        this.networkProtocol = new java.util.ArrayList<StringFilter>(networkProtocol);
    }
842443
public void registerProtocol(String protocol, IOProviderFrom<URL> provider) {
		protocols.put(protocol.toLowerCase(), provider);
	}
638772
public java.lang.String getProtocol() {
    java.lang.Object ref = protocol_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      protocol_ = s;
      return s;
    }
  }
51007
public String applicationProtocol() {
        SSLEngine engine = engine();
        if (!(engine instanceof ApplicationProtocolAccessor)) {
            return null;
        }

        return ((ApplicationProtocolAccessor) engine).getNegotiatedApplicationProtocol();
    }
345850
public void foundActiveSecondary(Protocol newSecondaryProtocol) throws SQLException {
    if (isSecondaryHostFail()) {
      if (isExplicitClosed()) {
        newSecondaryProtocol.close();
        return;
      }

      if (proxy.lock.tryLock()) {
        try {
          lockAndSwitchSecondary(newSecondaryProtocol);
        } finally {
          proxy.lock.unlock();
        }
      } else {
        if (!waitNewSecondaryProtocol.compareAndSet(null, newSecondaryProtocol)) {
          newSecondaryProtocol.close();
        }
      }
    } else {
      newSecondaryProtocol.close();
    }
  }
1056818
void resolveNetworkLocation(DatanodeInfo node) {
    List<String> names = new ArrayList<String>(1);
    if (dnsToSwitchMapping instanceof CachedDNSToSwitchMapping) {
      // get the node's IP address
      names.add(node.getHost());
    } else if (dnsToSwitchMapping instanceof StaticMapping) {
      names.add(toHostPort(node));
    } else {
      // get the node's host name
      String hostName = node.getHostName();
      int colon = hostName.indexOf(":");
      hostName = (colon == -1) ? hostName : hostName.substring(0, colon);
      names.add(hostName);
    }

    // resolve its network location
    List<String> rName = dnsToSwitchMapping.resolve(names);
    String networkLocation;
    if (rName == null) {
      LOG.error("The resolve call returned null! Using " +
        NetworkTopology.DEFAULT_RACK + " for host " + names);
      networkLocation = NetworkTopology.DEFAULT_RACK;
    } else {
      networkLocation = rName.get(0);
    }
    node.setNetworkLocation(networkLocation);
  }
659139
func (s *NetworkBinding) SetProtocol(v string) *NetworkBinding {
	s.Protocol = &v
	return s
}
947318
private boolean isProtocolSwitch(String pURL, HttpServletRequest pRequest) {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.entering(methodClassName, methodNames[IS_PROTOCOL_SWITCH]);
        }
        // Extract the protocol
        int ix = pURL.indexOf("://");
        if (ix < 0)
            return false;
        String protocol = pURL.substring(0, ix);

        // See if it's a switch between HTTP and HTTPS
        if (!((protocol.equalsIgnoreCase("http") && pRequest.getScheme().equalsIgnoreCase("https")) || (protocol.equalsIgnoreCase("https") && pRequest.getScheme().equalsIgnoreCase("http")))) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[IS_PROTOCOL_SWITCH], "false - No protocol switch.");
            }
            return false;
        }

        // Extract the host by searching for the first ':' or '/'
        int start = ix + 3;
        int end = start;
        int len = pURL.length();
        for (; end < len; end++) {
            char ch = pURL.charAt(end);
            if (ch == ':' || ch == '/')
                break;
        }
        String host = pURL.substring(start, end);

        // Get the IP address of the host
        InetAddress hostaddr;
        try {
            hostaddr = InetAddress.getByName(host);
        } catch (UnknownHostException exc) {
            com.ibm.ws.ffdc.FFDCFilter.processException(exc, "com.ibm.ws.session.SessionContext.isProtocolSwitch", "1760", this);
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.SEVERE, methodClassName, methodNames[IS_PROTOCOL_SWITCH], "CommonMessage.exception", exc);
            return false;
        }

        // See if it is not the same as this host
        if (!hostaddr.equals(getLocalHost())) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
                LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[IS_PROTOCOL_SWITCH], "false - Host Addresses are not equal");
            }
            return false;
        }
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_CORE.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_CORE.exiting(methodClassName, methodNames[IS_PROTOCOL_SWITCH], "true");
        }
        return true;
    }
927242
protected PrimitiveProtocol protocol() {
    PrimitiveProtocol protocol = this.protocol;
    if (protocol == null) {
      PrimitiveProtocolConfig<?> protocolConfig = config.getProtocolConfig();
      if (protocolConfig == null) {
        Collection<PartitionGroup> partitionGroups = managementService.getPartitionService().getPartitionGroups();
        if (partitionGroups.size() == 1) {
          protocol = partitionGroups.iterator().next().newProtocol();
        } else {
          String groups = Joiner.on(", ").join(partitionGroups.stream()
              .map(group -> group.name())
              .collect(Collectors.toList()));
          throw new ConfigurationException(String.format("Primitive protocol is ambiguous: %d partition groups found (%s)", partitionGroups.size(), groups));
        }
      } else {
        protocol = protocolConfig.getType().newProtocol(protocolConfig);
      }
    }
    return protocol;
  }
1168553
public ResourceAddress newResourceAddress(String location, String nextProtocol) {
        if (nextProtocol != null) {
            ResourceOptions options = ResourceOptions.FACTORY.newResourceOptions();
            options.setOption(NEXT_PROTOCOL, nextProtocol);
            return newResourceAddress(location, options);
        }
        else {
            return newResourceAddress(location);
        }
    }
1207401
@Override
    public String getProtocol() {
        String protocol = this.request.getVersion();
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "getProtocol: " + protocol);
        }
        return protocol;
    }
717258
protected void setServerProtocol(String serverProtocol) {

        if (CmsStringUtil.isEmpty(serverProtocol) || (WILDCARD.equals(serverProtocol))) {
            m_serverProtocol = WILDCARD;
        } else {
            int pos = serverProtocol.indexOf("/");
            if (pos > 0) {
                m_serverProtocol = serverProtocol.substring(0, pos).toLowerCase();
            } else {
                m_serverProtocol = serverProtocol.toLowerCase().trim();
            }
        }
    }
1076265
public void setNetworkDestinationIpV4(java.util.Collection<IpFilter> networkDestinationIpV4) {
        if (networkDestinationIpV4 == null) {
            this.networkDestinationIpV4 = null;
            return;
        }

        this.networkDestinationIpV4 = new java.util.ArrayList<IpFilter>(networkDestinationIpV4);
    }
124098
private void extractProtocolInfo(URI dsnUri) {
        String scheme = dsnUri.getScheme();
        if (scheme == null) {
            return;
        }
        String[] schemeDetails = scheme.split("\\+");
        protocolSettings.addAll(Arrays.asList(schemeDetails).subList(0, schemeDetails.length - 1));
        protocol = schemeDetails[schemeDetails.length - 1];
    }
698805
func (s *NetworkConnectionAction) SetProtocol(v string) *NetworkConnectionAction {
	s.Protocol = &v
	return s
}
627579
func (s *Stack) CheckNetworkProtocol(protocol tcpip.NetworkProtocolNumber) bool {
	_, ok := s.networkProtocols[protocol]
	return ok
}
783045
void gatherProtocol(int maxPos) throws IOException {
        // protocol buffer has max capacity, shouldn't need resizing
        try {
            while(this.bufferPosition < maxPos) {
                byte b = this.buffer[this.bufferPosition];
                this.bufferPosition++;

                if (gotCR) {
                    if (b == NatsConnection.LF) {
                        this.protocolBuffer.flip();
                        this.mode = Mode.PARSE_PROTO;
                        this.gotCR = false;
                        break;
                    } else {
                        throw new IllegalStateException("Bad socket data, no LF after CR");
                    }
                } else if (b == NatsConnection.CR) {
                    this.gotCR = true;
                } else {
                    if (!protocolBuffer.hasRemaining()) {
                        this.protocolBuffer = this.connection.enlargeBuffer(this.protocolBuffer, 0); // just double it
                    }
                    this.protocolBuffer.put(b);
                }
            }
        } catch (IllegalStateException | NumberFormatException | NullPointerException ex) {
            this.encounteredProtocolError(ex);
        }
    }