Class HTTP_Header

HTTP_Header

extends Kohana_HTTP_Header
extends ArrayObject

Implements: IteratorAggregate | Traversable | ArrayAccess | Serializable | Countable

The Kohana_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
Kohana
category
HTTP
author
Kohana Team
since
3.1.0
copyright
(c) Kohana Team
license
https://koseven.ga/LICENSE.md


Information

This class is a transparent base class for Kohana_HTTP_Header

Constants

Properties

Methods

Constants

DEFAULT_QUALITY

integer 1

STD_PROP_LIST

integer 1

ARRAY_AS_PROPS

integer 2

Properties

protected array $_accept_charset

Accept-Charset: parsed header

Default value: 
NULL

protected array $_accept_content

Accept: (content) types

Default value: 
NULL

protected array $_accept_encoding

Accept-Encoding: parsed header

Default value: 
NULL

protected array $_accept_language

Accept-Language: parsed header

Default value: 
NULL

protected array $_accept_language_list

Accept-Language: language list of parsed header

Default value: 
NULL

Methods

public __construct([ mixed $input = array(0) , int $flags = integer 0 , string $iterator_class = string(13) "ArrayIterator" ] ) (defined in Kohana_HTTP_Header)

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

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

Parameters

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

Source Code

public function __construct(array $input = [], $flags = 0, $iterator_class = 'ArrayIterator')
{
	/**
	 * @link http://www.w3.org/Protocols/rfc2616/rfc2616.html
	 *
	 * HTTP header declarations should be treated as case-insensitive
	 */
	$input = array_change_key_case( (array) $input, CASE_LOWER);

	parent::__construct($input, $flags, $iterator_class);
}

public __toString() (defined in Kohana_HTTP_Header)

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

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

Return Values

  • string

Source Code

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 ) (defined in Kohana_HTTP_Header)

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

Parameters

  • array $parts required - Accept header parts

Tags

  • Since - 3.2.0

Return Values

  • array

Source Code

public static function accept_quality(array $parts)
{
	$parsed = [];

	// Resource light iteration
	$parts_keys = array_keys($parts);
	foreach ($parts_keys as $key)
	{
		$value = trim(str_replace(["\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 ] ) (defined in Kohana_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);

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • mixed

Source Code

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 = Kohana::$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 ) (defined in Kohana_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

Parameters

  • string $charset required - Charset to examine

Tags

  • Since - 3.2.0

Return Values

  • float - The quality of the charset

Source Code

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 ] ) (defined in Kohana_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

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • float

Source Code

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 ] ) (defined in Kohana_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

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • float

Source Code

public function accepts_language_at_quality($language, $explicit = FALSE)
{
	if ($this->_accept_language === NULL)
	{
		if ($this->offsetExists('Accept-Language'))
		{
			$language_header = strtolower($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 ) (defined in Kohana_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);

Parameters

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

Tags

Return Values

  • string

Source Code

public static function create_cache_control(array $cache_control)
{
	$parts = [];

	foreach ($cache_control as $key => $value)
	{
		$parts[] = (is_int($key)) ? $value : ($key.'='.$value);
	}

	return implode(', ', $parts);
}

public exchangeArray(mixed $input ) (defined in Kohana_HTTP_Header)

Overloads the ArrayObject::exchangeArray() method to ensure that all keys are changed to lowercase.

Parameters

  • mixed $input required - $input

Tags

  • Since - 3.2.0

Return Values

  • array

Source Code

public function exchangeArray($input)
{
	/**
	 * @link http://www.w3.org/Protocols/rfc2616/rfc2616.html
	 *
	 * HTTP header declarations should be treated as case-insensitive
	 */
	$input = array_change_key_case( (array) $input, CASE_LOWER);

	return parent::exchangeArray($input);
}

public offsetExists(string $index ) (defined in Kohana_HTTP_Header)

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

Parameters

  • string $index required - $index

Tags

  • Since - 3.2.0

Return Values

  • boolean

Source Code

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

public offsetGet(string $index ) (defined in Kohana_HTTP_Header)

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

Parameters

  • string $index required - Index to retrieve

Tags

  • Since - 3.2.0

Return Values

  • mixed

Source Code

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

public offsetSet(mixed $index , mixed $newval [, boolean $replace = bool TRUE ] ) (defined in Kohana_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.

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • void

Source Code

public function offsetSet($index, $newval, $replace = TRUE)
{
	// Ensure the index is lowercase
	$index = strtolower($index);

	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 = [$current_value, $newval];
	}

	return parent::offsetSet($index, $current_value);
}

public offsetUnset(string $index ) (defined in Kohana_HTTP_Header)

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

Parameters

  • string $index required - $index

Tags

  • Since - 3.2.0

Return Values

  • void

Source Code

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

public static parse_accept_header([ string $accepts = NULL ] ) (defined in Kohana_HTTP_Header)

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

Parameters

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

Tags

Return Values

  • array

Source Code

public static function parse_accept_header($accepts = NULL)
{
	$accepts = explode(',', (string) $accepts);

	// If there is no accept, lets accept everything
	if ($accepts === NULL)
		return ['*' => ['*' => (float) HTTP_Header::DEFAULT_QUALITY]];

	// Parse the accept header qualities
	$accepts = HTTP_Header::accept_quality($accepts);

	$parsed_accept = [];

	// 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 ) (defined in Kohana_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'];
}

Parameters

  • array $cache_control required - Array of headers

Return Values

  • mixed

Source Code

public static function parse_cache_control($cache_control)
{
	$directives = explode(',', strtolower($cache_control));

	if ($directives === FALSE)
		return FALSE;

	$output = [];

	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 ] ) (defined in Kohana_HTTP_Header)

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

Parameters

  • string $charset = NULL - Charset string to parse

Tags

Return Values

  • array

Source Code

public static function parse_charset_header($charset = NULL)
{
	if ($charset === NULL)
	{
		return ['*' => (float) HTTP_Header::DEFAULT_QUALITY];
	}

	return HTTP_Header::accept_quality(explode(',', (string) $charset));
}

public static parse_encoding_header([ string $encoding = NULL ] ) (defined in Kohana_HTTP_Header)

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

Parameters

  • string $encoding = NULL - Charset string to parse

Tags

Return Values

  • array

Source Code

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

public parse_header_string(resource $resource , string $header_line ) (defined in Kohana_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');

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • int

Source Code

public function parse_header_string($resource, $header_line)
{
	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 ] ) (defined in Kohana_HTTP_Header)

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

Parameters

  • string $language = NULL - Charset string to parse

Tags

Return Values

  • array

Source Code

public static function parse_language_header($language = NULL)
{
	if ($language === NULL)
	{
		return ['*' => ['*' => (float) HTTP_Header::DEFAULT_QUALITY]];
	}

	$language = HTTP_Header::accept_quality(explode(',', (string) $language));

	$parsed_language = [];

	$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 ] ) (defined in Kohana_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)

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • string - Name of the preferred content type

Source Code

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 ) (defined in Kohana_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'

Parameters

  • array $charsets required - Charsets to test

Tags

  • Since - 3.2.0

Return Values

  • mixed - Preferred charset or `FALSE`

Source Code

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 ] ) (defined in Kohana_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';

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • mixed

Source Code

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 ] ) (defined in Kohana_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'

Parameters

  • array $languages required - $languages
  • boolean $explicit = bool FALSE - $explicit

Tags

  • Since - 3.2.0

Return Values

  • mixed

Source Code

public function preferred_language(array $languages, $explicit = FALSE)
{
	$ceiling   = 0;
	$preferred = FALSE;
	$languages = $this->_order_languages_as_received($languages, $explicit);

	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 ] ) (defined in Kohana_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

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • mixed

Source Code

public function send_headers(HTTP_Response $response = NULL, $replace = FALSE, $callback = NULL)
{
	$protocol = $response->protocol();
	$status = $response->status();

	// Create the response header
	$processed_headers = [$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: '.Kohana::$content_type.'; charset='.Kohana::$charset;
	}

	if (Kohana::$expose AND ! isset($headers['x-powered-by']))
	{
		$processed_headers[] = 'X-Powered-By: '.Kohana::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() (defined in ArrayObject)

public asort() (defined in ArrayObject)

public count() (defined in ArrayObject)

public getArrayCopy() (defined in ArrayObject)

public getFlags() (defined in ArrayObject)

public getIterator() (defined in ArrayObject)

public getIteratorClass() (defined in ArrayObject)

public ksort() (defined in ArrayObject)

public natcasesort() (defined in ArrayObject)

public natsort() (defined in ArrayObject)

public serialize() (defined in ArrayObject)

public setFlags() (defined in ArrayObject)

public setIteratorClass() (defined in ArrayObject)

public uasort() (defined in ArrayObject)

public uksort() (defined in ArrayObject)

public unserialize() (defined in ArrayObject)

protected _order_languages_as_received(array $languages [, boolean $explicit = bool FALSE ] ) (defined in Kohana_HTTP_Header)

Returns the reordered list of supplied $languages using the order from the Accept-Language: HTTP header.

Parameters

  • array $languages required - Languages to order
  • boolean $explicit = bool FALSE - $explicit

Tags

  • Since - 3.3.8

Return Values

  • array

Source Code

protected function _order_languages_as_received(array $languages, $explicit = FALSE)
{
	if ($this->_accept_language_list === NULL)
	{
		if ($this->offsetExists('Accept-Language'))
		{
			$language_header = strtolower($this->offsetGet('Accept-Language'));
		}
		else
		{
			$language_header = NULL;
		}

		$this->_accept_language_list = HTTP_Header::_parse_language_header_as_list($language_header);
	}

	$new_order = [];

	foreach ($this->_accept_language_list as $accept_language)
	{
		foreach ($languages as $key => $language)
		{
			if (($explicit AND $accept_language == $language) OR
				( ! $explicit AND substr($accept_language, 0, 2) == substr($language, 0, 2)))
			{
				$new_order[] = $language;

				unset($languages[$key]);
			}
		}
	}

	foreach ($languages as $language)
	{
		$new_order[] = $language;
	}

	return $new_order;
}

protected static _parse_language_header_as_list([ string $language = NULL ] ) (defined in Kohana_HTTP_Header)

Parses the Accept-Language: HTTP header and returns an array containing the language names.

Parameters

  • string $language = NULL - Charset string to parse

Tags

  • Since - 3.3.8

Return Values

  • array

Source Code

protected static function _parse_language_header_as_list($language = NULL)
{
	$languages = [];
	$language  = explode(',', strtolower($language));

	foreach ($language as $lang)
	{
		$matches = [];

		if (preg_match('/([\w-]+)\s*(;.*q.*)?/', $lang, $matches))
		{
			$languages[] = $matches[1];
		}
	}

	return $languages;
}

protected _send_headers_to_php(array $headers , boolean $replace ) (defined in Kohana_HTTP_Header)

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

Parameters

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

Tags

  • Since - 3.2.0

Return Values

  • self

Source Code

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;
}

Modules

Do you want to contribute to Koseven?

Koseven Logo

We need YOUR help!

This project is open source. What does this mean? YOU can help:
  • Found a bug? Report it on Github
  • Need a feature? Add it Here
  • Want to help? Join the Forum
Go to Github