Lower-cases and converts the specified header name into an {@link AsciiString}. If {@code "name"} is
a known header name, this method will return a pre-instantiated {@link AsciiString} to reduce
the allocation rate of {@link AsciiString}.
492629
public static AsciiString of(CharSequence name) {
        if (name instanceof AsciiString) {
            return of((AsciiString) name);
        }

        final String lowerCased = Ascii.toLowerCase(requireNonNull(name, "name"));
        final AsciiString cached = map.get(lowerCased);
        return cached != null ? cached : AsciiString.cached(lowerCased);
    }
638892
function(name) {
            if (/[A-Z]/.test(name.charAt(0)))
                return "default" + name;
            var firstLetter = name.charAt(0);
            return "default" + firstLetter.toUpperCase() + name.substring(1);
        }
418416
public String getHeader(String name)
  {
    if (_header != null)
    {
      String strVal = _header.getHeader(name);
      if (strVal != null)
        return strVal;
    }
    if (this.headerTable != null)
    {
      int i = 0;
      for (Object obj : headerTable[0])
      {
        String strVal = (String) obj;
        if (name.equals(strVal))
        {
          return (String) headerTable[1].get(i);
        }
        i++;
      }
    }
    return null;
  }
1030911
public final B addHeader(CharSequence name, Object value) {
        requireNonNull(name, "name");
        requireNonNull(value, "value");
        getOrCreateHeaders().addObject(HttpHeaderNames.of(name), value);
        return self();
    }
674580
@Nullable
    public String getHeader(String name) {
        requireNonNull(name);
        List<String> values = lazyMap.get().get(name.toLowerCase());
        if (values == null) {
            return null;
        }
        return values.get(0);
    }
604469
static String capitalizeAsciiOnly(String s) {
    if (s == null || s.isEmpty()) {
      return s;
    }
    char c = s.charAt(0);
    if (isLowerCaseAsciiOnly(c)) {
      return Character.toUpperCase(c) + s.substring(1);
    }
    return s;
  }
268465
def _get_header_correctly_cased(header_name):
    

    header_name = header_name.capitalize()

    matches = re.findall(_REGEX_FOR_LOWERCASE_HEADERS, header_name)

    for match in matches:
        header_name = (re.sub(match, match.upper(), header_name))

    return header_name
1182494
public static ImmutableSet<String> lowercaseWordSet(final Class<?> origin, final String resource,
                                                        final boolean eliminatePrepAndConj) throws IOException {
        return ImmutableSet.copyOf(new HashSet<String>() {{
            readResource(origin, resource, new NullReturnLineProcessor() {
                @Override
                public boolean processLine(@Nonnull final String line) {
                    final String l = simplify(line);
                    if (!l.isEmpty() && !l.startsWith("#")) {
                        for (final String part : SPACES.split(l)) {
                            if (eliminatePrepAndConj) {
                                final String wordType = Dictionary.checkup(part);
                                if (wordType != null && (wordType.startsWith("IN") || wordType.startsWith("CC"))) {
                                    continue;
                                }
                            }
                            // add to the containing HashSet we are currently in the init block of
                            add(toEngLowerCase(clean(part)));
                        }
                    }
                    return true;
                }
            });
        }});
    }
567910
public T header(String name, String value) {
		return header(name, value, true);
	}
51735
public static Set<String> namesAsString(Headers<CharSequence, CharSequence, ?> headers) {
        return new CharSequenceDelegatingStringSet(headers.names());
    }
1032088
public String putHeader(final String name, final String value) {
        if (headers == null) {
            headers = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        }
        return headers.put(name, value);
    }
632955
public static HeaderTypes create(final String name) {
        if (name == null) {
            throw new IllegalArgumentException("header name may not be null");
        }
        String type = name.trim().toLowerCase(Locale.ENGLISH);
        if (type.length() == 0) {
            throw new IllegalArgumentException("header name may not be empty");
        }
        return new HeaderTypes(name);
    }
1182842
String nameTokenFor(String name) {
        Integer token = nameToToken.get(name);
        if (token == null) {
            token = nameToToken.size();
            nameToToken.put(name, token);
        }
        return "#" + token;
    }
903925
public String getHeader(String name) {
        Vector<String> v = getHeaders(name);
        if (v == null) {
            return null;
        }

        return v.firstElement();
    }
1151662
public static String capitalizeHeader(String header) {
		StringTokenizer st = new StringTokenizer(header, "-");
		StringBuilder out = new StringBuilder();
		while (st.hasMoreTokens()) {
			String l = st.nextToken();
			out.append(Character.toUpperCase(l.charAt(0)));
			if (l.length() > 1) {
				out.append(l.substring(1));
			}
			if (st.hasMoreTokens())
				out.append('-');
		}
		return out.toString();
	}
953841
public static String convertUnderscoreNameToClassName(String name) {
        StringBuffer result = new StringBuffer();
        boolean nextIsUpper = false;

        if (name != null) {
            int len = name.length();

            if (len > 0) {
                String s = String.valueOf(name.charAt(0));

                result.append(s.toUpperCase());

                for (int i = 1; i < len; i++) {
                    s = String.valueOf(name.charAt(i));

                    if ("_".equals(s)) {
                        nextIsUpper = true;
                    } else {
                        if (nextIsUpper) {
                            result.append(s.toUpperCase());
                            nextIsUpper = false;
                        } else {
                            result.append(s.toLowerCase());
                        }
                    }
                }
            }
        }

        return result.toString();
    }
1366500
public T header(Header name, String value) {
		return header(name.toString(), value, true);
	}