public __construct( string $uri [, array $client_params = array(0) , bool $allow_external = bool TRUE , array $injected_routes = array(0) ] ) (defined in Kohana_Request)

$request = new Request($uri);

Parameters

• string $uri required - URI of the request
• array $client_params = array(0) - Array of params to pass to the request client
• bool $allow_external = bool TRUE - Allow external requests? (deprecated in 3.3)
• array $injected_routes = array(0) - An array of routes to use, for testing

Tags

• Throws - Request_Exception
• Uses - Route::all, Route::matches

Return Values

• void

public function __construct($uri, $client_params = array(), $allow_external = TRUE, $injected_routes = array())
{
	$client_params = is_array($client_params) ? $client_params : array();

	// Initialise the header
	$this->_header = new HTTP_Header(array());

	// Assign injected routes
	$this->_routes = $injected_routes;

	// Cleanse query parameters from URI (faster that parse_url())
	$split_uri = explode('?', $uri);
	$uri = array_shift($split_uri);

	// Initial request has global $_GET already applied
	if (Request::$initial !== NULL)
	{
		if ($split_uri)
		{
			parse_str($split_uri[0], $this->_get);
		}
	}

	// Detect protocol (if present)
	// $allow_external = FALSE prevents the default index.php from
	// being able to proxy external pages.
	if ( ! $allow_external OR strpos($uri, '://') === FALSE)
	{
		// Remove trailing slashes from the URI
		$this->_uri = trim($uri, '/');

		// Apply the client
		$this->_client = new Request_Client_Internal($client_params);
	}
	else
	{
		// Create a route
		$this->_route = new Route($uri);

		// Store the URI
		$this->_uri = $uri;

		// Set the security setting if required
		if (strpos($uri, 'https://') === 0)
		{
			$this->secure(TRUE);
		}

		// Set external state
		$this->_external = TRUE;

		// Setup the client
		$this->_client = Request_Client_External::factory($client_params);
	}
}

public __toString( ) (defined in Kohana_Request)

echo $request;

Return Values

• string

public function __toString()
{
	return $this->render();
}

public static accept_encoding( [ string $type = NULL ] ) (defined in Kohana_Request)

$encodings = Request::accept_encoding();

Parameters

• string $type = NULL - Encoding type

Tags

• Deprecated - since version 3.3.0
• Uses - Request::_parse_accept

Return Values

• mixed - An array of all types or a specific type as a string

public static function accept_encoding($type = NULL)
{
	static $accepts;

	if ($accepts === NULL)
	{
		// Parse the HTTP_ACCEPT_LANGUAGE header
		$accepts = Request::_parse_accept($_SERVER['HTTP_ACCEPT_ENCODING']);
	}

	if (isset($type))
	{
		// Return the quality setting for this type
		return isset($accepts[$type]) ? $accepts[$type] : FALSE;
	}

	return $accepts;
}

public static accept_lang( [ string $lang = NULL ] ) (defined in Kohana_Request)

$langs = Request::accept_lang();

Parameters

• string $lang = NULL - Language code

Tags

• Deprecated - since version 3.3.0
• Uses - Request::_parse_accept

Return Values

• mixed - An array of all types or a specific type as a string

public static function accept_lang($lang = NULL)
{
	static $accepts;

	if ($accepts === NULL)
	{
		// Parse the HTTP_ACCEPT_LANGUAGE header
		$accepts = Request::_parse_accept($_SERVER['HTTP_ACCEPT_LANGUAGE']);
	}

	if (isset($lang))
	{
		// Return the quality setting for this lang
		return isset($accepts[$lang]) ? $accepts[$lang] : FALSE;
	}

	return $accepts;
}

public static accept_type( [ string $type = NULL ] ) (defined in Kohana_Request)

$types = Request::accept_type();

Parameters

• string $type = NULL - Content MIME type

Tags

• Deprecated - since version 3.3.0
• Uses - Request::_parse_accept

Return Values

• mixed - An array of all types or a specific type as a string

public static function accept_type($type = NULL)
{
	static $accepts;

	if ($accepts === NULL)
	{
		// Parse the HTTP_ACCEPT header
		$accepts = Request::_parse_accept($_SERVER['HTTP_ACCEPT'], array('*/*' => 1.0));
	}

	if (isset($type))
	{
		// Return the quality setting for this type
		return isset($accepts[$type]) ? $accepts[$type] : $accepts['*/*'];
	}

	return $accepts;
}

public action( [ string $action = NULL ] ) (defined in Kohana_Request)

Parameters

• string $action = NULL - Action to execute the controller from

Return Values

• mixed

public function action($action = NULL)
{
	if ($action === NULL)
	{
		// Act as a getter
		return $this->_action;
	}

	// Act as a setter
	$this->_action = (string) $action;

	return $this;
}

public body( [ string $content = NULL ] ) (defined in Kohana_Request)

Parameters

• string $content = NULL - Content to set to the object

Return Values

• mixed

public function body($content = NULL)
{
	if ($content === NULL)
	{
		// Act as a getter
		return $this->_body;
	}

	// Act as a setter
	$this->_body = $content;

	return $this;
}

public client( ) (defined in Kohana_Request)

Return Values

• Request_Client
• self

public function client(Request_Client $client = NULL)
{
	if ($client === NULL)
		return $this->_client;
	else
	{
		$this->_client = $client;
		return $this;
	}
}

public content_length( ) (defined in Kohana_Request)

Return Values

• integer

public function content_length()
{
	return strlen($this->body());
}

public controller( [ string $controller = NULL ] ) (defined in Kohana_Request)

Parameters

• string $controller = NULL - Controller to execute the action

Return Values

• mixed

public function controller($controller = NULL)
{
	if ($controller === NULL)
	{
		// Act as a getter
		return $this->_controller;
	}

	// Act as a setter
	$this->_controller = (string) $controller;

	return $this;
}

public cookie( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request)

Parameters

• mixed $key = NULL - Cookie name, or array of cookie values
• string $value = NULL - Value to set to cookie

Return Values

• string
• mixed

public function cookie($key = NULL, $value = NULL)
{
	if (is_array($key))
	{
		// Act as a setter, replace all cookies
		$this->_cookies = $key;
		return $this;
	}
	elseif ($key === NULL)
	{
		// Act as a getter, all cookies
		return $this->_cookies;
	}
	elseif ($value === NULL)
	{
		// Act as a getting, single cookie
		return isset($this->_cookies[$key]) ? $this->_cookies[$key] : NULL;
	}

	// Act as a setter for a single cookie
	$this->_cookies[$key] = (string) $value;

	return $this;
}

public static current( ) (defined in Kohana_Request)

$request = Request::current();

Tags

• Since - 3.0.5

Return Values

• Request

public static function current()
{
	return Request::$current;
}

public static detect_uri( ) (defined in Kohana_Request)

$uri = Request::detect_uri();

Tags

• Throws - Kohana_Exception
• Since - 3.0.8

Return Values

• string - URI of the main request

public static function detect_uri()
{
	if ( ! empty($_SERVER['PATH_INFO']))
	{
		// PATH_INFO does not contain the docroot or index
		$uri = $_SERVER['PATH_INFO'];
	}
	else
	{
		// REQUEST_URI and PHP_SELF include the docroot and index

		if (isset($_SERVER['REQUEST_URI']))
		{
			/**
			 * We use REQUEST_URI as the fallback value. The reason
			 * for this is we might have a malformed URL such as:
			 *
			 *  http://localhost/http://example.com/judge.php
			 *
			 * which parse_url can't handle. So rather than leave empty
			 * handed, we'll use this.
			 */
			$uri = $_SERVER['REQUEST_URI'];

			if ($request_uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH))
			{
				// Valid URL path found, set it.
				$uri = $request_uri;
			}

			// Decode the request URI
			$uri = rawurldecode($uri);
		}
		elseif (isset($_SERVER['PHP_SELF']))
		{
			$uri = $_SERVER['PHP_SELF'];
		}
		elseif (isset($_SERVER['REDIRECT_URL']))
		{
			$uri = $_SERVER['REDIRECT_URL'];
		}
		else
		{
			// If you ever see this error, please report an issue at http://dev.kohanaphp.com/projects/kohana3/issues
			// along with any relevant information about your web server setup. Thanks!
			throw new Kohana_Exception('Unable to detect the URI using PATH_INFO, REQUEST_URI, PHP_SELF or REDIRECT_URL');
		}

		// Get the path from the base URL, including the index file
		$base_url = parse_url(Kohana::$base_url, PHP_URL_PATH);

		if (strpos($uri, $base_url) === 0)
		{
			// Remove the base URL from the URI
			$uri = (string) substr($uri, strlen($base_url));
		}

		if (Kohana::$index_file AND strpos($uri, Kohana::$index_file) === 0)
		{
			// Remove the index file from the URI
			$uri = (string) substr($uri, strlen(Kohana::$index_file));
		}
	}

	return $uri;
}

public directory( [ string $directory = NULL ] ) (defined in Kohana_Request)

Parameters

• string $directory = NULL - Directory to execute the controller from

Return Values

• mixed

public function directory($directory = NULL)
{
	if ($directory === NULL)
	{
		// Act as a getter
		return $this->_directory;
	}

	// Act as a setter
	$this->_directory = (string) $directory;

	return $this;
}

public execute( ) (defined in Kohana_Request)

$request->execute();

Tags

• Throws - Request_Exception, HTTP_Exception_404
• Uses - [Kohana::$profiling], [Profiler]

Return Values

• Response

public function execute()
{
	if ( ! $this->_external)
	{
		$processed = Request::process($this, $this->_routes);

		if ($processed)
		{
			// Store the matching route
			$this->_route = $processed['route'];
			$params = $processed['params'];

			// Is this route external?
			$this->_external = $this->_route->is_external();

			if (isset($params['directory']))
			{
				// Controllers are in a sub-directory
				$this->_directory = $params['directory'];
			}

			// Store the controller
			$this->_controller = $params['controller'];

			// Store the action
			$this->_action = (isset($params['action']))
				? $params['action']
				: Route::$default_action;

			// These are accessible as public vars and can be overloaded
			unset($params['controller'], $params['action'], $params['directory']);

			// Params cannot be changed once matched
			$this->_params = $params;
		}
	}

	if ( ! $this->_route instanceof Route)
	{
		return HTTP_Exception::factory(404, 'Unable to find a route to match the URI: :uri', array(
			':uri' => $this->_uri,
		))->request($this)
			->get_response();
	}

	if ( ! $this->_client instanceof Request_Client)
	{
		throw new Request_Exception('Unable to execute :uri without a Kohana_Request_Client', array(
			':uri' => $this->_uri,
		));
	}

	return $this->_client->execute($this);
}

public static factory( [ string $uri = bool TRUE , array $client_params = array(0) , bool $allow_external = bool TRUE , array $injected_routes = array(0) ] ) (defined in Kohana_Request)

$request = Request::factory($uri);

Parameters

• string $uri = bool TRUE - URI of the request
• array $client_params = array(0) - An array of params to pass to the request client
• bool $allow_external = bool TRUE - Allow external requests? (deprecated in 3.3)
• array $injected_routes = array(0) - An array of routes to use, for testing

Tags

• Throws - Request_Exception
• Uses - Route::all, Route::matches

Return Values

• void|Request

public static function factory($uri = TRUE, $client_params = array(), $allow_external = TRUE, $injected_routes = array())
{
	// If this is the initial request
	if ( ! Request::$initial)
	{
		$protocol = HTTP::$protocol;

		if (isset($_SERVER['REQUEST_METHOD']))
		{
			// Use the server request method
			$method = $_SERVER['REQUEST_METHOD'];
		}
		else
		{
			// Default to GET requests
			$method = HTTP_Request::GET;
		}

		if (( ! empty($_SERVER['HTTPS']) AND filter_var($_SERVER['HTTPS'], FILTER_VALIDATE_BOOLEAN))
		   OR (isset($_SERVER['HTTP_X_FORWARDED_PROTO'])
		   	   AND $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https')
		       AND in_array($_SERVER['REMOTE_ADDR'], Request::$trusted_proxies))
		{
			// This request is secure
			$secure = TRUE;
		}

		if (isset($_SERVER['HTTP_REFERER']))
		{
			// There is a referrer for this request
			$referrer = $_SERVER['HTTP_REFERER'];
		}

		if (isset($_SERVER['HTTP_USER_AGENT']))
		{
			// Browser type
			Request::$user_agent = $_SERVER['HTTP_USER_AGENT'];
		}

		if (isset($_SERVER['HTTP_X_REQUESTED_WITH']))
		{
			// Typically used to denote AJAX requests
			$requested_with = $_SERVER['HTTP_X_REQUESTED_WITH'];
		}

		if (isset($_SERVER['HTTP_X_FORWARDED_FOR'])
		    AND isset($_SERVER['REMOTE_ADDR'])
		    AND in_array($_SERVER['REMOTE_ADDR'], Request::$trusted_proxies))
		{
			// Use the forwarded IP address, typically set when the
			// client is using a proxy server.
			// Format: "X-Forwarded-For: client1, proxy1, proxy2"
			$client_ips = explode(',', $_SERVER['HTTP_X_FORWARDED_FOR']);

			Request::$client_ip = array_shift($client_ips);

			unset($client_ips);
		}
		elseif (isset($_SERVER['HTTP_CLIENT_IP'])
		        AND isset($_SERVER['REMOTE_ADDR'])
		        AND in_array($_SERVER['REMOTE_ADDR'], Request::$trusted_proxies))
		{
			// Use the forwarded IP address, typically set when the
			// client is using a proxy server.
			$client_ips = explode(',', $_SERVER['HTTP_CLIENT_IP']);

			Request::$client_ip = array_shift($client_ips);

			unset($client_ips);
		}
		elseif (isset($_SERVER['REMOTE_ADDR']))
		{
			// The remote IP address
			Request::$client_ip = $_SERVER['REMOTE_ADDR'];
		}

		if ($method !== HTTP_Request::GET)
		{
			// Ensure the raw body is saved for future use
			$body = file_get_contents('php://input');
		}

		if ($uri === TRUE)
		{
			// Attempt to guess the proper URI
			$uri = Request::detect_uri();
		}

		$cookies = array();

		if (($cookie_keys = array_keys($_COOKIE)))
		{
			foreach ($cookie_keys as $key)
			{
				$cookies[$key] = Cookie::get($key);
			}
		}

		// Create the instance singleton
		Request::$initial = $request = new Request($uri, $client_params, $allow_external, $injected_routes);

		// Store global GET and POST data in the initial request only
		$request->protocol($protocol)
			->query($_GET)
			->post($_POST);

		if (isset($secure))
		{
			// Set the request security
			$request->secure($secure);
		}

		if (isset($method))
		{
			// Set the request method
			$request->method($method);
		}

		if (isset($referrer))
		{
			// Set the referrer
			$request->referrer($referrer);
		}

		if (isset($requested_with))
		{
			// Apply the requested with variable
			$request->requested_with($requested_with);
		}

		if (isset($body))
		{
			// Set the request body (probably a PUT type)
			$request->body($body);
		}

		if (isset($cookies))
		{
			$request->cookie($cookies);
		}
	}
	else
	{
		$request = new Request($uri, $client_params, $allow_external, $injected_routes);
	}

	return $request;
}

public headers( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request)

Parameters

• mixed $key = NULL - Key or array of key/value pairs to set
• string $value = NULL - Value to set to the supplied key

Return Values

• mixed

public function headers($key = NULL, $value = NULL)
{
	if ($key instanceof HTTP_Header)
	{
		// Act a setter, replace all headers
		$this->_header = $key;

		return $this;
	}

	if (is_array($key))
	{
		// Act as a setter, replace all headers
		$this->_header->exchangeArray($key);

		return $this;
	}

	if ($this->_header->count() === 0 AND $this->is_initial())
	{
		// Lazy load the request headers
		$this->_header = HTTP::request_headers();
	}

	if ($key === NULL)
	{
		// Act as a getter, return all headers
		return $this->_header;
	}
	elseif ($value === NULL)
	{
		// Act as a getter, single header
		return ($this->_header->offsetExists($key)) ? $this->_header->offsetGet($key) : NULL;
	}

	// Act as a setter for a single header
	$this->_header[$key] = $value;

	return $this;
}

public static initial( ) (defined in Kohana_Request)

// Get the first request
$request = Request::initial();

// Test whether the current request is the first request
if (Request::initial() === Request::current())
     // Do something useful

Tags

• Since - 3.1.0

Return Values

• Request

public static function initial()
{
	return Request::$initial;
}

public is_ajax( ) (defined in Kohana_Request)

Return Values

• boolean

public function is_ajax()
{
	return ($this->requested_with() === 'xmlhttprequest');
}

public is_external( ) (defined in Kohana_Request)

if ( ! $request->is_external())
     // This is an internal request

Return Values

• boolean

public function is_external()
{
	return $this->_external;
}

public is_initial( ) (defined in Kohana_Request)

if ( ! $request->is_initial())
    // This is a sub request

Return Values

• boolean

public function is_initial()
{
	return ($this === Request::$initial);
}

public method( [ string $method = NULL ] ) (defined in Kohana_Request)

Parameters

• string $method = NULL - Method to use for this request

Return Values

• mixed

public function method($method = NULL)
{
	if ($method === NULL)
	{
		// Act as a getter
		return $this->_method;
	}

	// Act as a setter
	$this->_method = strtoupper($method);

	return $this;
}

public param( [ string $key = NULL , mixed $default = NULL ] ) (defined in Kohana_Request)

$id = $request->param('id');

Parameters

• string $key = NULL - Key of the value
• mixed $default = NULL - Default value if the key is not set

Return Values

• mixed

public function param($key = NULL, $default = NULL)
{
	if ($key === NULL)
	{
		// Return the full array
		return $this->_params;
	}

	return isset($this->_params[$key]) ? $this->_params[$key] : $default;
}

public post( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request)

Parameters

• mixed $key = NULL - Key or key value pairs to set
• string $value = NULL - Value to set to a key

Tags

• Uses - Arr::path

Return Values

• mixed

public function post($key = NULL, $value = NULL)
{
	if (is_array($key))
	{
		// Act as a setter, replace all fields
		$this->_post = $key;

		return $this;
	}

	if ($key === NULL)
	{
		// Act as a getter, all fields
		return $this->_post;
	}
	elseif ($value === NULL)
	{
		// Act as a getter, single field
		return Arr::path($this->_post, $key);
	}

	// Act as a setter, single field
	$this->_post[$key] = $value;

	return $this;
}

public static post_max_size_exceeded( ) (defined in Kohana_Request)

Tags

• Uses - Num::bytes, Arr::get

Return Values

• boolean

public static function post_max_size_exceeded()
{
	// Make sure the request method is POST
	if (Request::$initial->method() !== HTTP_Request::POST)
		return FALSE;

	// Get the post_max_size in bytes
	$max_bytes = Num::bytes(ini_get('post_max_size'));

	// Error occurred if method is POST, and content length is too long
	return (Arr::get($_SERVER, 'CONTENT_LENGTH') > $max_bytes);
}

public static process( object $request [, array $routes = NULL ] ) (defined in Kohana_Request)

Parameters

• object $request required - Request
• array $routes = NULL - Route

Return Values

• array

public static function process(Request $request, $routes = NULL)
{
	// Load routes
	$routes = (empty($routes)) ? Route::all() : $routes;
	$params = NULL;

	foreach ($routes as $name => $route)
	{
		// Use external routes for reverse routing only
		if ($route->is_external())
		{
			continue;
		}

		// We found something suitable
		if ($params = $route->matches($request))
		{
			return array(
				'params' => $params,
				'route' => $route,
			);
		}
	}

	return NULL;
}

public protocol( [ string $protocol = NULL ] ) (defined in Kohana_Request)

Parameters

• string $protocol = NULL - Protocol to set to the request

Return Values

• mixed

public function protocol($protocol = NULL)
{
	if ($protocol === NULL)
	{
		if ($this->_protocol)
			return $this->_protocol;
		else
			return $this->_protocol = HTTP::$protocol;
	}

	// Act as a setter
	$this->_protocol = strtoupper($protocol);
	return $this;
}

public query( [ mixed $key = NULL , string $value = NULL ] ) (defined in Kohana_Request)

Parameters

• mixed $key = NULL - Key or key value pairs to set
• string $value = NULL - Value to set to a key

Tags

• Uses - Arr::path

Return Values

• mixed

public function query($key = NULL, $value = NULL)
{
	if (is_array($key))
	{
		// Act as a setter, replace all query strings
		$this->_get = $key;

		return $this;
	}

	if ($key === NULL)
	{
		// Act as a getter, all query strings
		return $this->_get;
	}
	elseif ($value === NULL)
	{
		// Act as a getter, single query string
		return Arr::path($this->_get, $key);
	}

	// Act as a setter, single query string
	$this->_get[$key] = $value;

	return $this;
}

public referrer( [ string $referrer = NULL ] ) (defined in Kohana_Request)

Parameters

• string $referrer = NULL - $referrer

Return Values

• mixed

public function referrer($referrer = NULL)
{
	if ($referrer === NULL)
	{
		// Act as a getter
		return $this->_referrer;
	}

	// Act as a setter
	$this->_referrer = (string) $referrer;

	return $this;
}

public render( ) (defined in Kohana_Request)

Return Values

• string

public function render()
{
	if ( ! $post = $this->post())
	{
		$body = $this->body();
	}
	else
	{
		$this->headers('content-type',
			'application/x-www-form-urlencoded; charset='.Kohana::$charset);
		$body = http_build_query($post, NULL, '&');
	}

	// Set the content length
	$this->headers('content-length', (string) $this->content_length());

	// If Kohana expose, set the user-agent
	if (Kohana::$expose)
	{
		$this->headers('user-agent', Kohana::version());
	}

	// Prepare cookies
	if ($this->_cookies)
	{
		$cookie_string = array();

		// Parse each
		foreach ($this->_cookies as $key => $value)
		{
			$cookie_string[] = $key.'='.$value;
		}

		// Create the cookie string
		$this->_header['cookie'] = implode('; ', $cookie_string);
	}

	$output = $this->method().' '.$this->uri().' '.$this->protocol()."\r\n";
	$output .= (string) $this->_header;
	$output .= $body;

	return $output;
}

public requested_with( [ string $requested_with = NULL ] ) (defined in Kohana_Request)

Parameters

• string $requested_with = NULL - Requested with value

Return Values

• mixed

public function requested_with($requested_with = NULL)
{
	if ($requested_with === NULL)
	{
		// Act as a getter
		return $this->_requested_with;
	}

	// Act as a setter
	$this->_requested_with = strtolower($requested_with);

	return $this;
}

public route( [ string $route = NULL ] ) (defined in Kohana_Request)

Parameters

• string $route = NULL - $route

Return Values

• mixed

public function route(Route $route = NULL)
{
	if ($route === NULL)
	{
		// Act as a getter
		return $this->_route;
	}

	// Act as a setter
	$this->_route = $route;

	return $this;
}

public secure( [ boolean $secure = NULL ] ) (defined in Kohana_Request)

Parameters

• boolean $secure = NULL - Is this request secure?

Return Values

• mixed

public function secure($secure = NULL)
{
	if ($secure === NULL)
		return $this->_secure;

	// Act as a setter
	$this->_secure = (bool) $secure;
	return $this;
}

public uri( [ string $uri = NULL ] ) (defined in Kohana_Request)

Parameters

• string $uri = NULL - $uri

Return Values

• mixed

public function uri($uri = NULL)
{
	if ($uri === NULL)
	{
		// Act as a getter
		return empty($this->_uri) ? '/' : $this->_uri;
	}

	// Act as a setter
	$this->_uri = $uri;

	return $this;
}

public url( [ mixed $protocol = NULL ] ) (defined in Kohana_Request)

echo URL::site($this->request->uri(), $protocol);

Parameters

• mixed $protocol = NULL - Protocol string or Request object

Tags

• Since - 3.0.7
• Uses - URL::site

Return Values

• string

public function url($protocol = NULL)
{
	if ($this->is_external())
	{
		// If it's an external request return the URI
		return $this->uri();
	}

	// Create a URI with the current route, convert to a URL and returns
	return URL::site($this->uri(), $protocol);
}

public static user_agent( mixed $value ) (defined in Kohana_Request)

Parameters

• mixed $value required - Array or string to return: browser, version, robot, mobile, platform

Tags

• Uses - Request::$user_agent, Text::user_agent

Return Values

• mixed - Requested information, FALSE if nothing is found

public static function user_agent($value)
{
	return Text::user_agent(Request::$user_agent, $value);
}

protected static _parse_accept( string & $header [, array $accepts = NULL ] ) (defined in Kohana_Request)

$accept = Request::_parse_accept($header, $defaults);

Parameters

• byref string $header required - Header to parse
• array $accepts = NULL - Default values

Return Values

• array

protected static function _parse_accept( & $header, array $accepts = NULL)
{
	if ( ! empty($header))
	{
		// Get all of the types
		$types = explode(',', $header);

		foreach ($types as $type)
		{
			// Split the type into parts
			$parts = explode(';', $type);

			// Make the type only the MIME
			$type = trim(array_shift($parts));

			// Default quality is 1.0
			$quality = 1.0;

			foreach ($parts as $part)
			{
				// Prevent undefined $value notice below
				if (strpos($part, '=') === FALSE)
					continue;

				// Separate the key and value
				list ($key, $value) = explode('=', trim($part));

				if ($key === 'q')
				{
					// There is a quality for this type
					$quality = (float) trim($value);
				}
			}

			// Add the accept type and quality
			$accepts[$type] = $quality;
		}
	}

	// Make sure that accepts is an array
	$accepts = (array) $accepts;

	// Order by quality
	arsort($accepts);

	return $accepts;
}