tweet_live: comparison web/lib/Zend/Http/UserAgent.php

equal deleted inserted replaced

-:5e7a0fedabdf
+:877f952ae2bd
 * to license@zend.com so we can send you a copy immediately.
 *
 * @category   Zend
 * @package    Zend_Http_UserAgent
 * @subpackage UserAgent
-* @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+* @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
 /**
 * Lists of User Agent chains for testing :
 * - http://www.mobilemultimedia.be/fr/
 *
 * @category   Zend
 * @package    Zend_Http_UserAgent
 * @subpackage UserAgent
-* @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+* @copyright  Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
 class Zend_Http_UserAgent implements Serializable
 {
 /**
 * 'desktop' by default if the sequence return false for each item
 */
 const DEFAULT_BROWSER_TYPE = 'desktop';
 /**
 * Default User Agent chain to prevent empty value
 */
 const DEFAULT_HTTP_USER_AGENT = 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)';
 /**
 * Default Http Accept param to prevent empty value
 */
 const DEFAULT_HTTP_ACCEPT = "application/xhtml+xml";
 /**
 * Default markup language
 */
 const DEFAULT_MARKUP_LANGUAGE = "xhtml";
 /**
 * Browser type
 protected $_browserTypeClass = array();
 /**
 * Array to store config
 *
 * Default values are provided to ensure specific keys are present at
 * instantiation.
 *
 * @var array
 */
 protected $_config = array(
 'identification_sequence' => self::DEFAULT_IDENTIFICATION_SEQUENCE,
 'storage'                 => array(
 * - $_server
 * - $_browserType
 * - User-Agent (defined in $_server)
 * - HTTP Accept value (defined in $_server)
 * - $_storage
 *
 * @var bool
 */
 protected $_immutable = false;
 /**
 */
 protected $_matchLog = array();
 /**
 * Server variable
 *
 * @var array
 */
 protected $_server;
 /**
 */
 protected $_storage;
 /**
 * Constructor
 *
 * @param  null|array|Zend_Config|ArrayAccess $options
 * @return void
 */
 public function __construct($options = null)
 {
 if (null !== $options) {
 }
 }
 /**
 * Serialized representation of the object
 *
 * @return string
 */
 public function serialize()
 {
+$device = $this->getDevice();
 $spec = array(
 'browser_type' => $this->_browserType,
 'config'       => $this->_config,
-'device_class' => get_class($this->_device),
+'device_class' => get_class($device),
-'device'       => $this->_device->serialize(),
+'device'       => $device->serialize(),
 'user_agent'   => $this->getServerValue('http_user_agent'),
 'http_accept'  => $this->getServerValue('http_accept'),
 );
 return serialize($spec);
 }
 /**
 * Unserialize a previous representation of the object
 *
 * @param  string $serialized
 * @return void
 */
 public function unserialize($serialized)
 {
 $this->_device = new $deviceClass($deviceSpec);
 }
 /**
 * Configure instance
 *
 * @param  array|Zend_Config|ArrayAccess $options
 * @return Zend_Http_UserAgent
 */
 public function setOptions($options)
 {
 if ($options instanceof Zend_Config) {
 $options = $options->toArray();
 }
 if (!is_array($options)
 && !$options instanceof ArrayAccess
 && !$options instanceof Traversable
 ) {
 require_once 'Zend/Http/UserAgent/Exception.php';
 throw new Zend_Http_UserAgent_Exception(sprintf(
 'Invalid argument; expected array, Zend_Config object, or object implementing ArrayAccess and Traversable; received %s',
 return $this;
 }
 /**
 * Comparison of the UserAgent chain and browser signatures.
 *
 * The comparison is case-insensitive : the browser signatures must be in lower
 * case
 *
 * @param  string $deviceClass Name of class against which a match will be attempted
 * @return bool
 $userAgent = $this->getUserAgent();
 // Call match method on device class
 return call_user_func(
 array($deviceClass, 'match'),
 $userAgent,
 $this->getServer()
 );
 }
 /**
 $browserType = strtolower($browserType);
 if (isset($this->_browserTypeClass[$browserType])) {
 return $this->_browserTypeClass[$browserType];
 }
 if (isset($this->_config[$browserType])
 && isset($this->_config[$browserType]['device'])
 ) {
 $deviceConfig = $this->_config[$browserType]['device'];
 if (is_array($deviceConfig) && isset($deviceConfig['classname'])) {
 $device = (string) $deviceConfig['classname'];
 }
 /**
 * Returns the persistent storage handler
 *
 * Session storage is used by default unless a different storage adapter
 * has been set via the "persistent_storage_adapter" key. That key should
 * contain either a fully qualified class name, or a short name that
 * resolves via the plugin loader.
 *
 * @param  string $browser Browser identifier (User Agent chain)
 * @return Zend_Http_UserAgent_Storage
 */
 return $this->_config;
 }
 /**
 * Config parameters is an Array or a Zend_Config object
 *
 * The allowed parameters are :
 * - the identification sequence (can be empty) => desktop browser type is the
 * default browser type returned
 * $config['identification_sequence'] : ',' separated browser types
 * - the persistent storage adapter
 * $config['persistent_storage_adapter'] = "Session" or "NonPersistent"
 * - to add or replace a browser type device
 * $config[(type)]['device']['path']
 * $config[(type)]['device']['classname']
 * - to add or replace a browser type features adapter
 * $config[(type)]['features']['path']
 * $config[(type)]['features']['classname']
 *
 * @param  mixed $config (option) Config array
 * @return Zend_Http_UserAgent
 */
 public function setConfig($config = array())
 {
 if ($config instanceof Zend_Config) {
 $config = $config->toArray();
 }
 // Verify that Config parameters are in an array.
 if (!is_array($config) && !$config instanceof Traversable) {
 require_once 'Zend/Http/UserAgent/Exception.php';
 throw new Zend_Http_UserAgent_Exception(sprintf(
 'Config parameters must be in an array or a Traversable object; received "%s"',
 $this->_config = array_merge($this->_config, $config);
 return $this;
 }
 /**
-* @return the $device
+* Returns the device object
+*
+* This is the object that will contain the various discovered device
+* capabilities.
+*
+* @return Zend_Http_UserAgent_Device $device
 */
 public function getDevice()
 {
 if (null !== $this->_device) {
 return $this->_device;
 $userAgent = $this->getUserAgent();
 // search an existing identification in the session
 $storage = $this->getStorage($userAgent);
 if (!$storage->isEmpty()) {
 // If the user agent and features are already existing, the
 // Zend_Http_UserAgent object is serialized in the session
 $object = $storage->read();
 $this->unserialize($object);
 } else {
 // Otherwise, the identification is made and stored in the session.
 // Find the browser type:
 $this->setBrowserType($this->_matchUserAgent());
 $this->_createDevice();
 // put the result in storage:
 $this->getStorage($userAgent)
 ->write($this->serialize());
 }
 }
 /**
 * Retrieve the "$_SERVER" array
 *
 * Basically, the $_SERVER array or an equivalent container storing the
 * data that will be introspected.
 *
 * If the value has not been previously set, it sets itself from the
 * $_SERVER superglobal.
 *
 * @return array
 */
 public function getServer()
 }
 return $this->_server;
 }
 /**
-* Retrieve the "$_SERVER" array
+* Set the "$_SERVER" array
 *
 * Basically, the $_SERVER array or an equivalent container storing the
 * data that will be introspected.
 *
 * @param  array|ArrayAccess $server
 * @return void
 * @throws Zend_Http_UserAgent_Exception on invalid parameter
 return $this;
 }
 /**
 * Retrieve a server value
 *
 * @param  string $key
 * @return mixed
 */
 public function getServerValue($key)
 {
 return $this;
 }
 /**
 * Set plugin loader
 *
 * @param  string $type Type of plugin loader; one of 'storage', (?)
 * @param  string|Zend_Loader_PluginLoader $loader
 * @return Zend_Http_UserAgent
 */
 public function setPluginLoader($type, $loader)
 {
 $type       = $this->_validateLoaderType($type);
 return $this;
 }
 /**
 * Get a plugin loader
 *
 * @param  string $type A valid plugin loader type; see {@link $_loaderTypes}
 * @return Zend_Loader_PluginLoader
 */
 public function getPluginLoader($type)
 {
 }
 /**
 * Validate a plugin loader type
 *
 * Verifies that it is in {@link $_loaderTypes}, and returns a normalized
 * version of the type.
 *
 * @param  string $type
 * @return string
 * @throws Zend_Http_UserAgent_Exception on invalid type
 */
 protected function _validateLoaderType($type)
 {

changeset 807	877f952ae2bd
parent 207	621fa6caec0c
child 1230	68c69c656a2c