not some problem with a Header, or generating or reading a Header.
502366
static public int getStart(int field) {

        Integer iObject = (Integer) starts.get(new Integer(field));

        if (iObject == null) {
            throw new IllegalArgumentException(
                RB.singleton.getString(RB.UNEXPECTED_HEADER_KEY, field));
        }

        return iObject.intValue();
    }
611099
def header_name_check(header_name):
		
		header_match = WHTTPHeaders.header_name_re.match(header_name.encode('us-ascii'))
		return len(header_name) > 0 and header_match is not None
995653
private function buildHeaderResponse()
    {
        foreach (explode(
            "\n",
            substr($this->output, 0, $this->info['header_size'])
        ) as $val) {
            $val = trim($val);
            if (! empty($val)) {
                $this->headerResponse[] = $val;
            }
        }
        $this->output = substr($this->output, $this->info['header_size']);
    }
22009
def set_header(self, header, value):
        
        # requests>=2.11 only accepts `str` or `bytes` header values
        # raising an exception here, instead of leaving it to `requests` makes
        # it easy to know where we passed a wrong header type in the code.
        if not isinstance(value, (str, bytes)):
            raise TypeError("header values must be str or bytes, but %s value has type %s" % (header, type(value)))
        self._headers[header] = value
608064
def header(self, item0, *items):
        
        self.txt(item0)
        at_x = None
        for item in items:
            if at_x is None:
                at_x = item
            else:
                self.txt(item, at_x=at_x)
                at_x = None
1273349
public function loadHeader()
    {
        $this->openFile('r');

        $header = $this->getLine();
        $this->line--; // because we don't want to count header line

        $this->initializeHeader($header);
    }
487071
function checkHeaders(stream, item) {
    var headers, ret = true;
    if (!stream.parsedHeaders) {
        stream.parsedHeaders = true;
        headers = stream.headers = gatherHeaders(item);
        stream.headersLength = headers.length;
    }
    if (!stream.hasWrittenHeaders) {
        stream.totalCount++;
        stream.push(Buffer.from(stream.formatter(stream.headers, true), "utf8"));
        stream.hasWrittenHeaders = true;
        ret = isHashArray(item) || !isArray(item);
    }
    return ret;
}
1047568
function printHeadingCB(err, heading) {
    if (err) {
        console.log(err);
        return;
    }
    console.log(heading * 180 / Math.PI);
}
1218157
public void setHead(Object[] h) {

        headers = new Object[h.length];

        // System.arraycopy(h, 0, headers, 0, h.length);
        for (int i = 0; i < h.length; i++) {
            headers[i] = h[i];
        }
    }
68297
def accept(self):  # type: () -> str
        
        accept = self.headers.get('Accept')

        if not accept or accept == _content_types.ANY:
            return self._default_accept
        else:
            return accept
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
  }
366921
private static boolean isApplicationHeader(String key) {
    // Don't allow HTTP/2 pseudo headers or content-type to be added by the application.
    return (!key.startsWith(":")
            && !CONTENT_TYPE_KEY.name().equalsIgnoreCase(key))
            && !USER_AGENT_KEY.name().equalsIgnoreCase(key);
  }
10442
function(name, value) {
    var header = { raw: value };
    this.headers[Utils.headerize(name)] = [header];
  }
895717
Header readHeader(@NonNull InputStream input) throws IOException {
        byte version = (byte) input.read();
        int keyLength = BitConverter.readInt(input);
        int valueLength = BitConverter.readInt(input);
        long entryVersion = BitConverter.readLong(input);
        validateHeader(keyLength, valueLength);
        return new Header(version, keyLength, valueLength, entryVersion);
    }
348140
def header(self):
    '''
    

    '''
    if self._header is None:
      self._header = self._read_half_frame_header(self.data)

    return self._header
117458
def assertNotHeader(self, name, value=None, *args, **kwargs):
        
        return not self.assertHeader(name, value)
90878
def h_v_t(header, key):
        
        if key not in header:
            key = key.title()

            if key not in header:
                raise ValueError("Unexpected header in response, missing: " + key + " headers:\n" + str(header))

        return header[key]