field-key ::= %x4B.3A *WSP key header-eol<p>
<tt>K:</tt>
424120
Rule FieldKey() {
		return Sequence(String("K:"),
				ZeroOrMore(WSP()).suppressNode(),
				Key(), HeaderEol()).label(FieldKey);
	}
596310
private int matchNextHeader(int i, String key)
  {
    int size = _headerSize;
    int length = key.length();

    char []keyBuf = _headerBuffer;
    char []toLowerAscii = _toLowerAscii;

    for (; i < size; i++) {
      CharSegment header = _headerKeys[i];

      if (header.length() != length)
        continue;

      int offset = header.offset();

      int j;
      for (j = 0; j < length; j++) {
        char a = key.charAt(j);
        char b = keyBuf[offset + j];
        
        if (a == b) {
          continue;
        }
        else if (toLowerAscii[a] != toLowerAscii[b]) {
          break;
        }
      }

      if (j == length) {
        return i;
      }
    }

    return -1;
  }
325329
function getRelayHandleKey(
  handleName: string,
  key: ?string,
  fieldName: ?string,
): string {
  if (key && key !== DEFAULT_HANDLE_KEY) {
    return `__${key}_${handleName}`;
  }

  invariant(
    fieldName != null,
    'getRelayHandleKey: Expected either `fieldName` or `key` in `handle` to be provided',
  );
  return `__${fieldName}_${handleName}`;
}
1254990
HpackHeaderField getHeaderField(int index) {
        HeaderEntry entry = head;
        while (index-- >= 0) {
            entry = entry.before;
        }
        return entry;
    }
1216433
def parameter_key(term)
      string = term.to_s
      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
      string
    end
637632
protected String resolveProtocolKey(String key) {
        return MotorbikeSecurityType.SSL.equals(securityType) ? Srl.replace(key, ".smtp.", ".smtps.") : key;
    }
469367
public String getHeaderFieldKey(int pIndex) {
        // TODO: getInputStream() first, to make sure we have header fields
        if (pIndex >= responseHeaders.length) {
            return null;
        }
        String field = responseHeaders[pIndex];

        if (StringUtil.isEmpty(field)) {
            return null;
        }
        int idx = field.indexOf(':');

        return StringUtil.toLowerCase(((idx > 0)
                ? field.substring(0, idx)
                : field));
    }
154117
Rule AbcHeader() {
		return FirstOf(
				SequenceS(
						OptionalS(FieldNumber()),
						OptionalS(TitleFields()),
						ZeroOrMoreS(OtherFields()),
						FieldKey()),
				SequenceS(
						OptionalS(FieldNumber()),
						TitleFields(),
						ZeroOrMoreS(OtherFields()),
						OptionalS(FieldKey())),
				SequenceS(
					FieldNumber(),
					OptionalS(TitleFields()),
					ZeroOrMoreS(OtherFields()),
					OptionalS(FieldKey()))
			)
			.label(AbcHeader);
	}
278320
function getKey(key) {
  if(this.conf.transform) {
    if(typeof(this.conf.transform.key) == 'function') {
      return this.conf.transform.key.call(this, key);
    }
  }
  key = delimited(key, this.conf.delimiter);
  key = key.replace(/- /, this.conf.delimiter);
  key = key.replace(/[^a-zA-Z0-9_]/, '');
  if(this.conf.prefix) {
    return this.conf.prefix + this.conf.delimiter + key.toLowerCase()
  }
  return key.toLowerCase();
}
210385
public Key<?> getKey(FieldLiteral<?> field) {
    return getKey(field.getFieldType().getType(), field.getBindingAnnotation());
  }
404142
Rule FieldMacro() {
		return Sequence(String("m:"),
				ZeroOrMore(WSP()).suppressNode(),
				OneOrMore(FirstOf(WSP(), VCHAR()))
					.label("Macro").suppressSubnodes(),
				HeaderEol()
				).label(FieldMacro);
	}
342849
public KeyedStream<T, Tuple> keyBy(int... fields) {
		if (getType() instanceof BasicArrayTypeInfo || getType() instanceof PrimitiveArrayTypeInfo) {
			return keyBy(KeySelectorUtil.getSelectorForArray(fields, getType()));
		} else {
			return keyBy(new Keys.ExpressionKeys<>(fields, getType()));
		}
	}
1180510
private static String key(String name) {
        return WHITE_SPACE.matcher(name).replaceAll(".").toLowerCase(Locale.ENGLISH);
    }
908017
private String getCacheKey(HttpServerExchange exchange) {
        String host = null;

        HeaderMap headerMap = exchange.getRequestHeaders();
        if (headerMap != null) {
            HeaderValues headerValues = headerMap.get(Header.X_FORWARDED_FOR.toHttpString());
            if (headerValues != null) {
                host = headerValues.element();
            }
        }
        
        if (StringUtils.isBlank(host)) {
            InetSocketAddress inetSocketAddress = exchange.getSourceAddress();
            if (inetSocketAddress != null) {
                host = inetSocketAddress.getHostString();
            }
        }
        
        if (StringUtils.isNotBlank(host)) {
            host = host.toLowerCase(Locale.ENGLISH);
        }
        
        String url = exchange.getRequestURL();
        if (StringUtils.isNotBlank(url)) {
            url = url.toLowerCase(Locale.ENGLISH);
        }
        
        return url + host;
    }
90742
@Override
  public void setHeader(String key, String value)
  {
    int tail;

    if (_headerSize > 0) {
      tail = (_headerValues[_headerSize - 1].offset()
              + _headerValues[_headerSize - 1].length());
    }
    else {
      tail = 0;
    }

    int keyLength = key.length();
    int valueLength = value.length();
    char []headerBuffer = _headerBuffer;
    
    for (int i = keyLength - 1; i >= 0; i--) {
      headerBuffer[tail + i] = key.charAt(i);
    }

    _headerKeys[_headerSize].init(headerBuffer, tail, keyLength);

    tail += keyLength;

    for (int i = valueLength - 1; i >= 0; i--) {
      headerBuffer[tail + i] = value.charAt(i);
    }

    _headerValues[_headerSize].init(headerBuffer, tail, valueLength);
    _headerSize++;
    // XXX: size
  }
627138
private void processKeyField(Field field) {
    String fieldName = field.getName();
    Class<?> type = field.getType();
    if (!type.equals(DatastoreKey.class)) {
      String message = String.format("Invalid type, %s, for Key field %s in class %s. ", type,
          fieldName, entityClass);
      throw new EntityManagerException(message);
    }
    KeyMetadata keyMetadata = new KeyMetadata(field);
    entityMetadata.setKeyMetadata(keyMetadata);
  }
826539
Rule FieldMeter() {
		return Sequence(String("M:"),
				ZeroOrMore(WSP()).suppressNode(),
				OptionalS(TimeSignature()), HeaderEol()).label(FieldMeter);
	}