Populates with the next header

@return Do any more headers remain to be populated?
172818
public boolean populate(OggPacket packet) {
        // TODO Finish the flac support properly
        if (type == OggStreamIdentifier.OGG_FLAC) {
            if (tags == null) {
                tags = new FlacTags(packet);
                return true;
            } else {
                // TODO Finish FLAC support
                return false;
            }
        }

        OggStreamPacket sPacket = createNext(packet);
        if (sPacket instanceof OggAudioTagsHeader) {
            tags = (OggAudioTagsHeader)sPacket;

            // Are there more headers to come?
            if (type == OggStreamIdentifier.OGG_VORBIS) {
                return true;
            } else {
                return false;
            }
        }
        if (sPacket instanceof OggAudioSetupHeader) {
            setup = (OggAudioSetupHeader)sPacket;

            // Setup is always last
            return false;
        }

        throw new IllegalArgumentException("Expecting header packet but got " + sPacket);
    }
1275702
public void resetHeader() {
        this.header = null;
        DocListener listener;
		for (Iterator iterator = listeners.iterator(); iterator.hasNext();) {
            listener = (DocListener) iterator.next();
            listener.resetHeader();
        }
    }
99334
private void getHeadersFromFrame() {
        byte[] hbf = null;
        if (currentFrame.getFrameType() == FrameTypes.HEADERS || currentFrame.getFrameType() == FrameTypes.PUSHPROMISEHEADERS) {
            hbf = ((FrameHeaders) currentFrame).getHeaderBlockFragment();
        } else if (currentFrame.getFrameType() == FrameTypes.CONTINUATION) {
            hbf = ((FrameContinuation) currentFrame).getHeaderBlockFragment();
        }

        if (hbf != null) {
            if (headerBlock == null) {
                headerBlock = new ArrayList<byte[]>();
            }
            headerBlock.add(hbf);
        }
    }
551075
public static Map<String, String> headers(){
        Map<String, String> headers = new HashMap<>();
        Enumeration<String> names = RequestContext.getHttpRequest().getHeaderNames();
        while (names.hasMoreElements()) {
            String name = names.nextElement();
            headers.put(name, RequestContext.getHttpRequest().getHeader(name));
        }
        return headers;
    }
714824
private void buildHeaders() {
		if (!headers.isEmpty()) {
			for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
				List<String> values = entry.getValue();

				for (String value : values) {
					connection.addRequestProperty(entry.getKey(), value);
				}
			}
		}
	}
727191
public boolean next()
    {
        if (this.iter == null) {
            this.iter = new ArrayList<>(this.values).iterator();
        }
        final boolean ret = this.iter.hasNext();
        if (ret) {
            this.current = this.iter.next();
        }
        return ret;
    }
856733
private function _loadHeaders()
    {
        $this->shapeType = false;
        $this->recordNumber = $this->_loadData('N', 4);
        if ($this->recordNumber === false) {
            return;
        }
        // We read the length of the record
        $this->size = $this->_loadData('N', 4);
        if ($this->size === false) {
            return;
        }
        $this->size = $this->size * 2 + 8;
        $this->shapeType = $this->_loadData('V', 4);
    }
441694
@Override
    public Map<String, List<String>> headers() {
        if (headers != null) {
            return headers;
        }
        headers = new HashMap<>();
        final MultiMap requestHeaders = request.headers();
        Set<String> names = requestHeaders.names();
        for (String name : names) {
            headers.put(name, requestHeaders.getAll(name));
        }
        return headers;
    }
698472
private void fillHeader()
  {
    byte[] buffer = _indexBuffer;
    
    Arrays.fill(buffer, (byte) 0x0);
    
    int index = 0;
    
    BitsUtil.writeLong(buffer, index, _segment.getSequence());
    index += 8;
    
    byte []tableKey = _table.tableKey();
    System.arraycopy(tableKey, 0, buffer, index, tableKey.length);
    index += tableKey.length;

    /*
    BitsUtil.writeInt16(buffer, index, tail);
    index += 2;
  
    buffer[index] = (byte) (isCont ? 1 : 0);
    index++;
    */
    
    _indexTail = index;
    
    fillFooter(buffer, FOOTER_OFFSET, index, false);
  }
436357
public Headers toHeaders() {
        Headers headers = new Headers();
        if (!getMatch().isEmpty()) {
            headers = headers.add(new Header(HeaderConstants.IF_MATCH, buildTagHeaderValue(getMatch())));
        }
        if (!getNoneMatch().isEmpty()) {
            headers = headers.add(new Header(HeaderConstants.IF_NONE_MATCH, buildTagHeaderValue(getNoneMatch())));
        }
        if (modifiedSince.isPresent()) {
            headers = headers.set(HeaderUtils.toHttpDate(HeaderConstants.IF_MODIFIED_SINCE, modifiedSince.get()));
        }
        if (unModifiedSince.isPresent()) {
            headers = headers.set(HeaderUtils.toHttpDate(HeaderConstants.IF_UNMODIFIED_SINCE, unModifiedSince.get()));
        }

        return headers;
    }
53000
public String[] getHeader() {
        
        return columns.stream()
            .map(c -> headerMapper.toMap(c, configuration, groups))
            .toArray(n -> new String[n]);
        
    }
134102
def _parse_and_store_headers(self):
        

        header_storage = self._store_header()
        header_storage.send(None)

        for header_line in self._next_header_line():
            if header_line is None:
                self._buffer += yield
                continue
            else:
                header_storage.send(header_line)

        self.headers = header_storage.send(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);
    }
234078
public function headers()
    {
        if($this->headers === null) {
            $data = $this->serverRequest->getHeaders();
            $this->headers = $this->builder->headers($data);
        }
        
        return $this->headers;
    }
849990
public HttpHeaders add(HttpHeaders headers) {
        if (headers == null) {
            throw new NullPointerException("headers");
        }
        for (Map.Entry<String, String> e: headers) {
            add(e.getKey(), e.getValue());
        }
        return this;
    }
335275
public function getAvailableHtmlHeadEntrySet()
    {
        $set = parent::getAvailableHtmlHeadEntrySet();

        foreach ($this->children as $child_widget) {
            $set->addEntrySet($child_widget->getAvailableHtmlHeadEntrySet());
        }

        return $set;
    }
1293796
public List<String> getHeader() {
		if (false == config.containsHeader) {
			throw new IllegalStateException("No header available - header parsing is disabled");
		}
		if (lineNo == 0) {
			throw new IllegalStateException("No header available - call nextRow() first");
		}
		return header.fields;
	}