Return each fields' header code.

@return string
425267
private function header()
    {
        $fields = collect($this->entity->fields)->unique('type')->all();
        $codeArray = [];

        foreach ($fields as $name => $options) {
            $type = ucwords($options['type']);
            $className = 'Jaimeeee\\Panel\\Fields\\'.$type.'\\'.$type.'Field';

            if (method_exists($className, 'header')) {
                $codeArray[] = '  '.$className::header();
            }
        }

        return implode(chr(10), $codeArray);
    }
884791
public function getRequestAllowedHeaders(): string
	{
		$headers = $this->settings[self::KEY_ALLOWED_HEADERS];

		// 'all headers' is not a header actually so we remove it
		unset($headers[self::VALUE_ALLOW_ALL_HEADERS]);

		$enabled = $this->getEnabledItems($headers);

		return \implode(', ', $enabled);
	}
437301
public function toString()
    {
        if (empty($this->headerSigners) && empty($this->bodySigners)) {
            return parent::toString();
        }

        $this->saveMessage();

        $this->doSign();

        $string = parent::toString();

        $this->restoreMessage();

        return $string;
    }
256582
public function getHeaders(): array
    {
        if ($this->headers === null && $this->headersText !== null) {
            $this->headers = [];

            foreach (explode("\n", $this->headersText) as $line) {
                $pos = strpos($line, ':');

                if ($pos === false) {
                    // this is one-line header
                    $this->headers[$line] = null;
                } else {
                    $name = substr($line, 0, $pos);
                    $value = substr($line, $pos + 1);
                    $this->headers[$name] = trim($value);
                }
            }
        }

        return $this->headers ?? [];
    }
1264990
public function getAllCodeFields()
    {
        static $fields = false; // Using static so it will be refreshed once per request

        if ($fields === false) {
            $fields = array();
            $model  = $this->createTrackClass('Model\\FieldMaintenanceModel');
            $rows   = $model->load(array('gtf_field_code IS NOT NULL'), array('gtf_field_code' => SORT_ASC));

            if ($rows) {
                foreach ($rows as $row) {
                    $key = FieldsDefinition::makeKey($row['sub'], $row['gtf_id_field']);
                    $fields[$key] = $row['gtf_field_code'];
                }
            }
        }

        return $fields;
    }
159744
public function toString()
    {
        $headers = $this->toArray();
        $content = '';

        //Serialise the headers to a string
        foreach ($headers as $name => $value) {
            $content .= sprintf("%s %s\r\n", $name.':', $value);
        }

        return $content;
    }
515899
public function headers()
    {
        $headers = [];
        foreach ($this->headers as $header) {
            $headers[$header->name()] = $header->value();
        }

        return $headers;
    }
1069545
public function getHeaders()
    {
        $headers = [];

        foreach($this->headers as $name => $values) {
            $headers[strtolower($name)] = $values;
        }

        return $headers;
    }
549151
public function getHeader() : string
    {
        $salt = $this->getEncodedSalt();
        $hmac = $this->getEncodedHMAC();

        if ($this->version === 2) {
            $data = \base64_encode(\json_encode([
                'access_token' => $this->token->accessToken,
                'date' => $this->date,
                'hmac' => $hmac,
                'salt' => $salt,
                'v' => 2
            ]));

            return "HMAC {$data}";
        }

        // The version 1 HMAC is returned by default
        return "HMAC {$this->token->accessToken},{$hmac},{$salt}";
    }
957629
public function getCode()
    {
        if (is_null($this->code)) {
            $code = 0;
            if (!empty($this->headers)) {
                foreach ($this->headers as $header) {
                    $matches = array();
                    preg_match('|HTTP/\d(\.\d)?\s+(\d+)(\s+.*)?|', $header, $matches);
                    if (isset($matches[2])) {
                        $code = (int)$matches[2];
                    }
                }
            }
            $this->code = $code;
        }
        return $this->code;
    }
234078
public function headers()
    {
        if($this->headers === null) {
            $data = $this->serverRequest->getHeaders();
            $this->headers = $this->builder->headers($data);
        }
        
        return $this->headers;
    }
774931
private function getHeaders()
    {
        $this->debug->groupCollapsed(__METHOD__);
        $cfg = &$this->cfg;
        $status = &$this->status;
        $this->debug->log('headersCache', $cfg['headersCache']);
        $headers = array();
        if ($cfg['headersCache'] === 'auto') {
            $iCur = $this->persist->get('i');
            $this->debug->log('iCur', $iCur);
            $cfg['headersCache'] = true;
            if ($iCur == 0 && !$status['submitted']) {
                $this->debug->log('First Page && not submitted');
                $cfg['headersCache'] = false;
            }
            if (isset($_SERVER['HTTP_USER_AGENT']) && \preg_match('/ MSIE 6\.\d;/', $_SERVER['HTTP_USER_AGENT'])) {
                $this->debug->log('IE6: do not cache or: will ALWAYS returned cached content.  side-effects: blank fields on back-button & page has expired message');
                $cfg['headersCache'] = false;
            }
            $this->debug->log('headersCache', $cfg['headersCache']);
        }
        if ($cfg['headersCache']) {
            $headers = array(
                // 'Pragma: public',
                'Cache-Control: private, max-age='.(60*30), // .', must-revalidate',
                'Last-Modified: '.\gmdate('D, d M Y H:i:s \G\M\T'),
                'Expires: '.\gmdate('D, d M Y H:i:s \G\M\T', \time()+60*30),
            );
        } else {
            $headers = array(
                // 'Pragma: no-cache',
                'Cache-Control: private, no-cache, no-store',   // HTTP/1.1
                'Expires: Mon, 26 Jul 1997 05:00:00 GMT',       // Date in the past
            );
        }
        $this->debug->groupEnd();
        return $headers;
    }
825375
protected function getAmzHeaders(): string
    {
        $amzHeaders = [];
        $headers = $this->request->getHeaders();
        foreach ($headers as $headerName => $headerValue) {
            if (0 === strpos(strtolower($headerName), 'x-amz-')) {
                $amzHeaders[strtolower($headerName)] = str_replace(["\r\n"], [' '], $headerValue[0])."\n";
            }
        }
        ksort($amzHeaders);

        $headerStr = '';
        foreach ($amzHeaders as $h => $v) {
            $headerStr .= $h.':'.$v;
        }

        return $headerStr;
    }
680112
public function getHeader()
    {
        switch ($this->type) {
            case self::TYPE_ERROR:
                $header = 'Error!';
                break;
            case self::TYPE_WARNING:
                $header = 'Warning!';
                break;
            case self::TYPE_INFO:
                $header = 'Info';
                break;
            case self::TYPE_SUCCESS:
                $header = 'Success';
                break;
            default:
                $header = 'Info';
                break;
        }

        return $header;
    }
403591
protected function _getHeaderHandleName()
    {
        $handleCode = $this->_scopeConfig->getValue(
            self::HEADER_LAYOUT_CONFIG_PATH,
            ScopeInterface::SCOPE_STORE
        );
        if (!$handleCode) {
            $handleCode = 1;
        }
        return self::HEADER_LAYOUT_HANDLE_PREFIX . $handleCode;
    }
985163
public static function getHeaders()
    {
        if (self::$headers === null) {
            if (function_exists('apache_request_headers')) {
                $headers = apache_request_headers();
            } else {
                $headers = array();
                if (isset($_SERVER['CONTENT_TYPE'])) {
                    $headers['Content-Type'] = $_SERVER['CONTENT_TYPE'];
                }
                if (isset($_ENV['CONTENT_TYPE'])) {
                    $headers['Content-Type'] = $_ENV['CONTENT_TYPE'];
                }
                foreach ($_SERVER as $key => $value) {
                    if (substr($key, 0, 5) == "HTTP_") {
                        // this is chaos, basically it is just there to capitalize the first
                        // letter of every word that is not an initial HTTP and strip HTTP
                        // code from przemek
                        $key = str_replace(" ", "-", ucwords(strtolower(str_replace("_", " ", substr($key, 5)))));
                        $headers[$key] = $value;
                    }
                }
            }
            self::$headers = $headers;
        }

        return self::$headers;
    }
138825
public function getHeaders()
    {
        // Don't pass the first row!!
        $this->openFile(0);
        $this->columns = fgetcsv($this->fileHandler, null, $this->csvDelimiter);
        $this->closeFile();
    }