模块

HTTP_Header
继承自 ArrayObject

实现: Countable | Serializable | ArrayAccess | Traversable | IteratorAggregate

The BootPHP_HTTP_Header class provides an Object-Orientated interface to HTTP headers. This can parse header arrays returned from the PHP functions `apache_request_headers()` or the `http_parse_headers()` function available within the PECL HTTP library.

package
BootPHP
category
HTTP
author
Tinsh
copyright
© 2005-2016 Kilofox Studio

该类在 SYSPATH/classes/http/header.php 第 15 行声明。

常量

DEFAULT_QUALITY

integer 1

STD_PROP_LIST

integer 1

ARRAY_AS_PROPS

integer 2

属性

protected array $_accept_charset

Accept-Charset: parsed header

protected array $_accept_content

Accept: (content) types

protected array $_accept_encoding

Accept-Encoding: parsed header

protected array $_accept_language

Accept-Language: parsed header

方法

public __construct( [ mixed $input = array(0) , int $flags = NULL , string $iterator_class = string(13) "ArrayIterator" ] ) (在 HTTP_Header 中定义)

Constructor method for BootPHP_HTTP_Header. Uses the standard constructor of the parent `ArrayObject` class.

 $header_object = new HTTP_Header(array('x-powered-by' => 'BootPHP 3.1.x', 'expires' => '...'));

参数

  • mixed $input = array(0) - Input array
  • int $flags = NULL - Flags
  • string $iterator_class = string(13) "ArrayIterator" - The iterator class to use

源代码

public function __construct(array $input = array(), $flags = NULL, $iterator_class = 'ArrayIterator')
{
	/**
	 * HTTP header declarations should be treated as case-insensitive
	 */
	$input = array_change_key_case($input, CASE_LOWER);
	parent::__construct($input, $flags, $iterator_class);
}

public __toString( ) (在 HTTP_Header 中定义)

Returns the header object as a string, including the terminating new line

 // Return the header as a string
 echo (string) $request->headers();

返回值

  • string

源代码

public function __toString()
{
	$header = '';
	foreach ($this as $key => $value)
	{
		// Put the keys back the Case-Convention expected
		$key = Text::ucfirst($key);
		if (is_array($value))
		{
			$header .= $key . ': ' . (implode(', ', $value)) . "\r\n";
		}
		else
		{
			$header .= $key . ': ' . $value . "\r\n";
		}
	}
	return $header . "\r\n";
}

public static accept_quality( array $parts ) (在 HTTP_Header 中定义)

Parses an Accept(-*) header and detects the quality

参数

  • array $parts required - Accept header parts

返回值

  • array

源代码

public static function accept_quality(array $parts)
{
	$parsed = array();
	// Resource light iteration
	$parts_keys = array_keys($parts);
	foreach ($parts_keys as $key)
	{
		$value = trim(str_replace(array("\r", "\n"), '', $parts[$key]));
		$pattern = '~\b(\;\s*+)?q\s*+=\s*+([.0-9]+)~';
		// If there is no quality directive, return default
		if (!preg_match($pattern, $value, $quality))
		{
			$parsed[$value] = (float) HTTP_Header::DEFAULT_QUALITY;
		}
		else
		{
			$quality = $quality[2];
			if ($quality[0] === '.')
			{
				$quality = '0' . $quality;
			}
			// Remove the quality value from the string and apply quality
			$parsed[trim(preg_replace($pattern, '', $value, 1), '; ')] = (float) $quality;
		}
	}
	return $parsed;
}

public accepts_at_quality( string $type [, boolean $explicit = bool false ] ) (在 HTTP_Header 中定义)

Returns the accept quality of a submitted mime type based on the request `Accept:` header. If the `$explicit` argument is `true`, only precise matches will be returned, excluding all wildcard (`*`) directives.

 // Accept: application/xml; application/json; q=.5; text/html; q=.2, text/*
 // Accept quality for application/json

 // $quality = 0.5
 $quality = $request->headers()->accepts_at_quality('application/json');

 // $quality_explicit = false
 $quality_explicit = $request->headers()->accepts_at_quality('text/plain', true);

参数

  • string $type required - Type
  • boolean $explicit = bool false - Explicit check, excludes `*`

返回值

  • mixed

源代码

public function accepts_at_quality($type, $explicit = false)
{
	// Parse Accept header if required
	if ($this->_accept_content === NULL)
	{
		if ($this->offsetExists('Accept'))
		{
			$accept = $this->offsetGet('Accept');
		}
		else
		{
			$accept = '*/*';
		}
		$this->_accept_content = HTTP_Header::parse_accept_header($accept);
	}
	// If not a real mime, try and find it in config
	if (strpos($type, '/') === false)
	{
		$mime = BootPHP::$config->load('mimes.' . $type);
		if ($mime === NULL)
			return false;
		$quality = false;
		foreach ($mime as $_type)
		{
			$quality_check = $this->accepts_at_quality($_type, $explicit);
			$quality = ($quality_check > $quality) ? $quality_check : $quality;
		}
		return $quality;
	}
	$parts = explode('/', $type, 2);
	if (isset($this->_accept_content[$parts[0]][$parts[1]]))
	{
		return $this->_accept_content[$parts[0]][$parts[1]];
	}
	elseif ($explicit === true)
	{
		return false;
	}
	else
	{
		if (isset($this->_accept_content[$parts[0]]['*']))
		{
			return $this->_accept_content[$parts[0]]['*'];
		}
		elseif (isset($this->_accept_content['*']['*']))
		{
			return $this->_accept_content['*']['*'];
		}
		else
		{
			return false;
		}
	}
}

public accepts_charset_at_quality( string $charset ) (在 HTTP_Header 中定义)

Returns the quality of the supplied `$charset` argument. This method will automatically parse the `Accept-Charset` header if present and return the associated resolved quality value.

  // Accept-Charset: utf-8, utf-16; q=.8, iso-8859-1; q=.5
  $quality = $header->accepts_charset_at_quality('utf-8');
        // $quality = (float) 1

参数

  • string $charset required - Charset to examine

返回值

  • float - The quality of the charset

源代码

public function accepts_charset_at_quality($charset)
{
	if ($this->_accept_charset === NULL)
	{
		if ($this->offsetExists('Accept-Charset'))
		{
			$charset_header = strtolower($this->offsetGet('Accept-Charset'));
			$this->_accept_charset = HTTP_Header::parse_charset_header($charset_header);
		}
		else
		{
			$this->_accept_charset = HTTP_Header::parse_charset_header(NULL);
		}
	}
	$charset = strtolower($charset);
	if (isset($this->_accept_charset[$charset]))
	{
		return $this->_accept_charset[$charset];
	}
	elseif (isset($this->_accept_charset['*']))
	{
		return $this->_accept_charset['*'];
	}
	elseif ($charset === 'iso-8859-1')
	{
		return (float) 1;
	}
	return (float) 0;
}

public accepts_encoding_at_quality( string $encoding [, boolean $explicit = bool false ] ) (在 HTTP_Header 中定义)

Returns the quality of the `$encoding` type passed to it. Encoding is usually compression such as `gzip`, but could be some other message encoding algorithm. This method allows explicit checks to be done ignoring wildcards.

  // Accept-Encoding: compress, gzip, *; q=.5
  $encoding = $header->accepts_encoding_at_quality('gzip');
  // $encoding = (float) 1.0s

参数

  • string $encoding required - Encoding type to interrogate
  • boolean $explicit = bool false - Explicit check, ignoring wildcards and `identity`

返回值

  • float

源代码

public function accepts_encoding_at_quality($encoding, $explicit = false)
{
	if ($this->_accept_encoding === NULL)
	{
		if ($this->offsetExists('Accept-Encoding'))
		{
			$encoding_header = $this->offsetGet('Accept-Encoding');
		}
		else
		{
			$encoding_header = NULL;
		}
		$this->_accept_encoding = HTTP_Header::parse_encoding_header($encoding_header);
	}
	// Normalize the encoding
	$encoding = strtolower($encoding);
	if (isset($this->_accept_encoding[$encoding]))
	{
		return $this->_accept_encoding[$encoding];
	}
	if ($explicit === false)
	{
		if (isset($this->_accept_encoding['*']))
		{
			return $this->_accept_encoding['*'];
		}
		elseif ($encoding === 'identity')
		{
			return (float) HTTP_Header::DEFAULT_QUALITY;
		}
	}
	return (float) 0;
}

public accepts_language_at_quality( string $language [, boolean $explicit = bool false ] ) (在 HTTP_Header 中定义)

Returns the quality of `$language` supplied, optionally ignoring wildcards if `$explicit` is set to a non-`false` value. If the quality is not found, `0.0` is returned.

 // Accept-Language: en-us, en-gb; q=.7, en; q=.5
 $lang = $header->accepts_language_at_quality('en-gb');
 // $lang = (float) 0.7

 $lang2 = $header->accepts_language_at_quality('en-au');
 // $lang2 = (float) 0.5

 $lang3 = $header->accepts_language_at_quality('en-au', true);
 // $lang3 = (float) 0.0

参数

  • string $language required - Language to interrogate
  • boolean $explicit = bool false - Explicit interrogation, `true` ignores wildcards

返回值

  • float

源代码

public function accepts_language_at_quality($language, $explicit = false)
{
	if ($this->_accept_language === NULL)
	{
		if ($this->offsetExists('Accept-Language'))
		{
			$language_header = $this->offsetGet('Accept-Language');
		}
		else
		{
			$language_header = NULL;
		}
		$this->_accept_language = HTTP_Header::parse_language_header($language_header);
	}
	// Normalize the language
	$language_parts = explode('-', strtolower($language), 2);
	if (isset($this->_accept_language[$language_parts[0]]))
	{
		if (isset($language_parts[1]))
		{
			if (isset($this->_accept_language[$language_parts[0]][$language_parts[1]]))
			{
				return $this->_accept_language[$language_parts[0]][$language_parts[1]];
			}
			elseif ($explicit === false AND isset($this->_accept_language[$language_parts[0]]['*']))
			{
				return $this->_accept_language[$language_parts[0]]['*'];
			}
		}
		elseif (isset($this->_accept_language[$language_parts[0]]['*']))
		{
			return $this->_accept_language[$language_parts[0]]['*'];
		}
	}
	if ($explicit === false AND isset($this->_accept_language['*']))
	{
		return $this->_accept_language['*'];
	}
	return (float) 0;
}

public static create_cache_control( array $cache_control ) (在 HTTP_Header 中定义)

Generates a Cache-Control HTTP header based on the supplied array.

 // Set the cache control headers you want to use
 $cache_control = array(
     'max-age'        => 3600,
     'must-revalidate',
     'public'
 );

 // Create the cache control header, creates :
 // cache-control: max-age=3600, must-revalidate, public
 $response->headers('Cache-Control', HTTP_Header::create_cache_control($cache_control);

参数

  • array $cache_control required - Cache-Control to render to string

Tags

返回值

  • string

源代码

public static function create_cache_control(array $cache_control)
{
	$parts = array();
	foreach ($cache_control as $key => $value)
	{
		$parts[] = (is_int($key)) ? $value : ($key . '=' . $value);
	}
	return implode(', ', $parts);
}

public offsetExists( string $index ) (在 HTTP_Header 中定义)

Overloads the `ArrayObject::offsetExists()` method to ensure keys are lowercase.

参数

  • string $index required - $index

返回值

  • boolean

源代码

public function offsetExists($index)
{
	return parent::offsetExists(strtolower($index));
}

public offsetGet( string $index ) (在 HTTP_Header 中定义)

Overload the `ArrayObject::offsetGet()` method to ensure that all keys passed to it are formatted correctly for this object.

参数

  • string $index required - Index to retrieve

返回值

  • mixed

源代码

public function offsetGet($index)
{
	return parent::offsetGet(strtolower($index));
}

public offsetSet( mixed $index , mixed $newval [, boolean $replace = bool true ] ) (在 HTTP_Header 中定义)

Overloads `ArrayObject::offsetSet()` to enable handling of header with multiple instances of the same directive. If the `$replace` flag is `false`, the header will be appended rather than replacing the original setting.

参数

  • mixed $index required - Index to set `$newval` to
  • mixed $newval required - New value to set
  • boolean $replace = bool true - Replace existing value

返回值

  • void

源代码

public function offsetSet($index, $newval, $replace = true)
{
	// Ensure the index is lowercase
	$index = strtolower($index);
	$newval = (string) $newval;
	if ($replace OR ! $this->offsetExists($index))
	{
		return parent::offsetSet($index, $newval);
	}
	$current_value = $this->offsetGet($index);
	if (is_array($current_value))
	{
		$current_value[] = $newval;
	}
	else
	{
		$current_value = array($current_value, $newval);
	}
	return parent::offsetSet($index, $current_value);
}

public offsetUnset( string $index ) (在 HTTP_Header 中定义)

Overloads the `ArrayObject::offsetUnset()` method to ensure keys are lowercase.

参数

  • string $index required - Index

返回值

  • void

源代码

public function offsetUnset($index)
{
	return parent::offsetUnset(strtolower($index));
}

public static parse_accept_header( [ string $accepts = NULL ] ) (在 HTTP_Header 中定义)

Parses the accept header to provide the correct quality values for each supplied accept type.

参数

  • string $accepts = NULL - Accept content header string to parse

返回值

  • array

源代码

public static function parse_accept_header($accepts = NULL)
{
	$accepts = explode(',', (string) $accepts);
	// If there is no accept, lets accept everything
	if ($accepts === NULL)
		return array('*' => array('*' => (float) HTTP_Header::DEFAULT_QUALITY));
	// Parse the accept header qualities
	$accepts = HTTP_Header::accept_quality($accepts);
	$parsed_accept = array();
	// This method of iteration uses less resource
	$keys = array_keys($accepts);
	foreach ($keys as $key)
	{
		// Extract the parts
		$parts = explode('/', $key, 2);
		// Invalid content type- bail
		if (!isset($parts[1]))
			continue;
		// Set the parsed output
		$parsed_accept[$parts[0]][$parts[1]] = $accepts[$key];
	}
	return $parsed_accept;
}

public static parse_cache_control( array $cache_control ) (在 HTTP_Header 中定义)

Parses the Cache-Control header and returning an array representation of the Cache-Control header.

 // Create the cache control header
 $response->headers('cache-control', 'max-age=3600, must-revalidate, public');

 // Parse the cache control header
 if ( $cache_control = HTTP_Header::parse_cache_control($response->headers('cache-control')) )
 {
      // Cache-Control header was found
      $maxage = $cache_control['max-age'];
 }

参数

  • array $cache_control required - Array of headers

返回值

  • mixed

源代码

public static function parse_cache_control($cache_control)
{
	$directives = explode(',', strtolower($cache_control));
	if ($directives === false)
		return false;
	$output = array();
	foreach ($directives as $directive)
	{
		if (strpos($directive, '=') !== false)
		{
			list($key, $value) = explode('=', trim($directive), 2);
			$output[$key] = ctype_digit($value) ? (int) $value : $value;
		}
		else
		{
			$output[] = trim($directive);
		}
	}
	return $output;
}

public static parse_charset_header( [ string $charset = NULL ] ) (在 HTTP_Header 中定义)

Parses the `Accept-Charset:` HTTP header and returns an array containing the charset and associated quality.

参数

  • string $charset = NULL - Charset string to parse

返回值

  • array

源代码

public static function parse_charset_header($charset = NULL)
{
	if ($charset === NULL)
	{
		return array('*' => (float) HTTP_Header::DEFAULT_QUALITY);
	}
	return HTTP_Header::accept_quality(explode(',', (string) $charset));
}

public static parse_encoding_header( [ string $encoding = NULL ] ) (在 HTTP_Header 中定义)

Parses the `Accept-Encoding:` HTTP header and returns an array containing the charsets and associated quality.

参数

  • string $encoding = NULL - Charset string to parse

返回值

  • array

源代码

public static function parse_encoding_header($encoding = NULL)
{
	// Accept everything
	if ($encoding === NULL)
	{
		return array('*' => (float) HTTP_Header::DEFAULT_QUALITY);
	}
	elseif ($encoding === '')
	{
		return array('identity' => (float) HTTP_Header::DEFAULT_QUALITY);
	}
	else
	{
		return HTTP_Header::accept_quality(explode(',', (string) $encoding));
	}
}

public parse_header_string( resource $resource , string $header_line ) (在 HTTP_Header 中定义)

Parses a HTTP Message header line and applies it to this HTTP_Header

 $header = $response->headers();
 $header->parse_header_string(NULL, 'content-type: application/json');

参数

  • resource $resource required - The resource (required by Curl API)
  • string $header_line required - The line from the header to parse

返回值

  • int

源代码

public function parse_header_string($resource, $header_line)
{
	$headers = array();
	if (preg_match_all('/(\w[^\s:]*):[ ]*([^\r\n]*(?:\r\n[ \t][^\r\n]*)*)/', $header_line, $matches))
	{
		foreach ($matches[0] as $key => $value)
		{
			$this->offsetSet($matches[1][$key], $matches[2][$key], false);
		}
	}
	return strlen($header_line);
}

public static parse_language_header( [ string $language = NULL ] ) (在 HTTP_Header 中定义)

Parses the `Accept-Language:` HTTP header and returns an array containing the languages and associated quality.

参数

  • string $language = NULL - Charset string to parse

返回值

  • array

源代码

public static function parse_language_header($language = NULL)
{
	if ($language === NULL)
	{
		return array('*' => array('*' => (float) HTTP_Header::DEFAULT_QUALITY));
	}
	$language = HTTP_Header::accept_quality(explode(',', (string) $language));
	$parsed_language = array();
	$keys = array_keys($language);
	foreach ($keys as $key)
	{
		// Extract the parts
		$parts = explode('-', $key, 2);
		// Invalid content type- bail
		if (!isset($parts[1]))
		{
			$parsed_language[$parts[0]]['*'] = $language[$key];
		}
		else
		{
			// Set the parsed output
			$parsed_language[$parts[0]][$parts[1]] = $language[$key];
		}
	}
	return $parsed_language;
}

public preferred_accept( array $types [, boolean $explicit = bool false ] ) (在 HTTP_Header 中定义)

Returns the preferred response content type based on the accept header quality settings. If items have the same quality value, the first item found in the array supplied as `$types` will be returned.

 // Get the preferred acceptable content type
 // Accept: text/html, application/json; q=.8, text/*
 $result = $header->preferred_accept(array(
     'text/html'
     'text/rtf',
     'application/json'
 )); // $result = 'application/json'

 $result = $header->preferred_accept(array(
     'text/rtf',
     'application/xml'
 ), true); // $result = false (none matched explicitly)

参数

  • array $types required - The content types to examine
  • boolean $explicit = bool false - Only allow explicit references, no wildcards

返回值

  • string - Name of the preferred content type

源代码

public function preferred_accept(array $types, $explicit = false)
{
	$preferred = false;
	$ceiling = 0;
	foreach ($types as $type)
	{
		$quality = $this->accepts_at_quality($type, $explicit);
		if ($quality > $ceiling)
		{
			$preferred = $type;
			$ceiling = $quality;
		}
	}
	return $preferred;
}

public preferred_charset( array $charsets ) (在 HTTP_Header 中定义)

Returns the preferred charset from the supplied array `$charsets` based on the `Accept-Charset` header directive.

  // Accept-Charset: utf-8, utf-16; q=.8, iso-8859-1; q=.5
  $charset = $header->preferred_charset(array(
      'utf-10', 'ascii', 'utf-16', 'utf-8'
  )); // $charset = 'utf-8'

参数

  • array $charsets required - Charsets to test

返回值

  • mixed - Preferred charset or `false`

源代码

public function preferred_charset(array $charsets)
{
	$preferred = false;
	$ceiling = 0;
	foreach ($charsets as $charset)
	{
		$quality = $this->accepts_charset_at_quality($charset);
		if ($quality > $ceiling)
		{
			$preferred = $charset;
			$ceiling = $quality;
		}
	}
	return $preferred;
}

public preferred_encoding( array $encodings [, boolean $explicit = bool false ] ) (在 HTTP_Header 中定义)

Returns the preferred message encoding type based on quality, and can optionally ignore wildcard references. If two or more encodings have the same quality, the first listed in `$encodings` will be returned.

 // Accept-Encoding: compress, gzip, *; q.5
 $encoding = $header->preferred_encoding(array(
      'gzip', 'bzip', 'blowfish'
 ));
 // $encoding = 'gzip';

参数

  • array $encodings required - Encodings to test against
  • boolean $explicit = bool false - Explicit check, if `true` wildcards are excluded

返回值

  • mixed

源代码

public function preferred_encoding(array $encodings, $explicit = false)
{
	$ceiling = 0;
	$preferred = false;
	foreach ($encodings as $encoding)
	{
		$quality = $this->accepts_encoding_at_quality($encoding, $explicit);
		if ($quality > $ceiling)
		{
			$ceiling = $quality;
			$preferred = $encoding;
		}
	}
	return $preferred;
}

public preferred_language( array $languages [, boolean $explicit = bool false ] ) (在 HTTP_Header 中定义)

Returns the preferred language from the supplied array `$languages` based on the `Accept-Language` header directive.

  // Accept-Language: en-us, en-gb; q=.7, en; q=.5
  $lang = $header->preferred_language(array(
      'en-gb', 'en-au', 'fr', 'es'
  )); // $lang = 'en-gb'

参数

  • array $languages required - Languages
  • boolean $explicit = bool false - Explicit

返回值

  • mixed

源代码

public function preferred_language(array $languages, $explicit = false)
{
	$ceiling = 0;
	$preferred = false;
	foreach ($languages as $language)
	{
		$quality = $this->accepts_language_at_quality($language, $explicit);
		if ($quality > $ceiling)
		{
			$ceiling = $quality;
			$preferred = $language;
		}
	}
	return $preferred;
}

public send_headers( [ HTTP_Response $response = NULL , boolean $replace = bool false , callback $callback = NULL ] ) (在 HTTP_Header 中定义)

Sends headers to the php processor, or supplied `$callback` argument. This method formats the headers correctly for output, re-instating their capitalization for transmission.

if you supply a custom header handler via `$callback`, it is recommended that `$response` is returned

参数

  • HTTP_Response $response = NULL - Header to send
  • boolean $replace = bool false - Replace existing value
  • callback $callback = NULL - Optional callback to replace PHP header function

返回值

  • mixed

源代码

public function send_headers($response = NULL, $replace = false, $callback = NULL)
{
	if ($response === NULL)
	{
		// Default to the initial request message
		$response = Request::initial()->response();
	}
	$protocol = $response->protocol();
	$status = $response->status();
	// Create the response header
	$processed_headers = array($protocol . ' ' . $status . ' ' . Response::$messages[$status]);
	// Get the headers array
	$headers = $response->headers()->getArrayCopy();
	foreach ($headers as $header => $value)
	{
		if (is_array($value))
		{
			$value = implode(', ', $value);
		}
		$processed_headers[] = Text::ucfirst($header) . ': ' . $value;
	}
	if (!isset($headers['content-type']))
	{
		$processed_headers[] = 'Content-Type: ' . BootPHP::$content_type .
			'; charset=' . BootPHP::$charset;
	}
	if (BootPHP::$expose AND ! isset($headers['x-powered-by']))
	{
		$processed_headers[] = 'X-Powered-By: BootPHP Framework ' . BootPHP::VERSION;
	}
	// Get the cookies and apply
	if ($cookies = $response->cookie())
	{
		$processed_headers['Set-Cookie'] = $cookies;
	}
	if (is_callable($callback))
	{
		// Use the callback method to set header
		return call_user_func($callback, $response, $processed_headers, $replace);
	}
	else
	{
		$this->_send_headers_to_php($processed_headers, $replace);
		return $response;
	}
}

public append( ) (在 ArrayObject 中定义)

public asort( ) (在 ArrayObject 中定义)

public count( ) (在 ArrayObject 中定义)

public exchangeArray( ) (在 ArrayObject 中定义)

public getArrayCopy( ) (在 ArrayObject 中定义)

public getFlags( ) (在 ArrayObject 中定义)

public getIterator( ) (在 ArrayObject 中定义)

public getIteratorClass( ) (在 ArrayObject 中定义)

public ksort( ) (在 ArrayObject 中定义)

public natcasesort( ) (在 ArrayObject 中定义)

public natsort( ) (在 ArrayObject 中定义)

public serialize( ) (在 ArrayObject 中定义)

public setFlags( ) (在 ArrayObject 中定义)

public setIteratorClass( ) (在 ArrayObject 中定义)

public uasort( ) (在 ArrayObject 中定义)

public uksort( ) (在 ArrayObject 中定义)

public unserialize( ) (在 ArrayObject 中定义)

protected _send_headers_to_php( array $headers , boolean $replace ) (在 HTTP_Header 中定义)

Sends the supplied headers to the PHP output buffer. If cookies are included in the message they will be handled appropriately.

参数

  • array $headers required - Headers to send to php
  • boolean $replace required - Replace existing headers

返回值

  • self

源代码

protected function _send_headers_to_php(array $headers, $replace)
{
	// If the headers have been sent, get out
	if (headers_sent())
		return $this;
	foreach ($headers as $key => $line)
	{
		if ($key == 'Set-Cookie' AND is_array($line))
		{
			// Send cookies
			foreach ($line as $name => $value)
			{
				Cookie::set($name, $value['value'], $value['expiration']);
			}
			continue;
		}
		header($line, $replace);
	}
	return $this;
}