: <?php                                                                           
                 : /**                                                                             
                 :  * HTTP_OAuth                                                                   
                 :  *                                                                              
                 :  * Implementation of the OAuth specification                                    
                 :  *                                                                              
                 :  * PHP version 5.2.0+                                                           
                 :  *                                                                              
                 :  * LICENSE: This source file is subject to the New BSD license that is          
                 :  * available through the world-wide-web at the following URI:                   
                 :  * http://www.opensource.org/licenses/bsd-license.php. If you did not receive   
                 :  * a copy of the New BSD License and are unable to obtain it through the web,   
                 :  * please send a note to license@php.net so we can mail you a copy immediately. 
                 :  *                                                                              
                 :  * @category  HTTP                                                              
                 :  * @package   HTTP_OAuth                                                        
                 :  * @author    Jeff Hodsdon <jeffhodsdon@gmail.com>                              
                 :  * @copyright 2009 Jeff Hodsdon <jeffhodsdon@gmail.com>                         
                 :  * @license   http://www.opensource.org/licenses/bsd-license.php New BSD License
                 :  * @link      http://pear.php.net/package/HTTP_OAuth                            
                 :  * @link      http://github.com/jeffhodsdon/HTTP_OAuth                          
                 :  */                                                                             
                 :                                                                                 
                 : require_once 'HTTP/OAuth.php';                                                  
                 :                                                                                 
                 : /**                                                                             
                 :  * HTTP_OAuth_Message                                                           
                 :  *                                                                              
                 :  * Main message class for Request and Response classes to extend from.  Provider
                 :  * and Consumer packages use this class as there parent for the request/response
                 :  * classes. This contains specification parameters handling and ArrayAccess,    
                 :  * Countable, IteratorAggregate features.                                       
                 :  *                                                                              
                 :  * @category  HTTP                                                              
                 :  * @package   HTTP_OAuth                                                        
                 :  * @author    Jeff Hodsdon <jeffhodsdon@gmail.com>                              
                 :  * @copyright 2009 Jeff Hodsdon <jeffhodsdon@gmail.com>                         
                 :  * @license   http://www.opensource.org/licenses/bsd-license.php New BSD License
                 :  * @link      http://pear.php.net/package/HTTP_OAuth                            
                 :  * @link      http://github.com/jeffhodsdon/HTTP_OAuth                          
                 :  */                                                                             
                 : abstract class HTTP_OAuth_Message                                               
                 : extends HTTP_OAuth                                                              
                 : implements ArrayAccess, Countable, IteratorAggregate                            
                 : {                                                                               
                 :                                                                                 
                 :     /**                                                                         
                 :      * OAuth Parameters                                                         
                 :      *                                                                          
                 :      * @var string $oauthParams OAuth parameters                                
                 :      */                                                                         
                 :     static protected $oauthParams = array(                                      
                 :         'consumer_key',                                                         
                 :         'token',                                                                
                 :         'token_secret',                                                         
                 :         'signature_method',                                                     
                 :         'signature',                                                            
                 :         'timestamp',                                                            
                 :         'nonce',                                                                
                 :         'verifier',                                                             
                 :         'version',                                                              
                 :         'callback',                                                             
                 :         'session_handle'                                                        
                 :     );                                                                          
                 :                                                                                 
                 :     /**                                                                         
                 :      * Parameters                                                               
                 :      *                                                                          
                 :      * @var array $parameters Parameters                                        
                 :      */                                                                         
                 :     protected $parameters = array();                                            
                 :                                                                                 
                 :     /**                                                                         
                 :      * Get OAuth specific parameters                                            
                 :      *                                                                          
                 :      * @return array OAuth specific parameters                                  
                 :      */                                                                         
                 :     public function getOAuthParameters()                                        
                 :     {                                                                           
               4 :         $params = array();                                                      
               4 :         foreach (self::$oauthParams as $param) {                                
               4 :             if ($this->$param !== null) {                                       
               4 :                 $params[$this->prefixParameter($param)] = $this->$param;        
               4 :             }                                                                   
               4 :         }                                                                       
                 :                                                                                 
               4 :         ksort($params);                                                         
                 :                                                                                 
               4 :         return $params;                                                         
                 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Get parameters                                                           
                 :      *                                                                          
                 :      * @return array Request's parameters                                       
                 :      */                                                                         
                 :     public function getParameters()                                             
                 :     {                                                                           
               8 :         $params = $this->parameters;                                            
               8 :         ksort($params);                                                         
                 :                                                                                 
               8 :         return $params;                                                         
                 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Set parameters                                                           
                 :      *                                                                          
                 :      * @param array $params Name => value pair array of parameters              
                 :      *                                                                          
                 :      * @return void                                                             
                 :      */                                                                         
                 :     public function setParameters(array $params)                                
                 :     {                                                                           
              20 :         foreach ($params as $name => $value) {                                  
              20 :             $this->parameters[$this->prefixParameter($name)] = $value;          
              20 :         }                                                                       
              20 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Get signature method                                                     
                 :      *                                                                          
                 :      * @return string Signature method                                          
                 :      */                                                                         
                 :     public function getSignatureMethod()                                        
                 :     {                                                                           
               5 :         if ($this->oauth_signature_method !== null) {                           
               3 :             return $this->oauth_signature_method;                               
                 :         }                                                                       
                 :                                                                                 
               2 :         return 'HMAC-SHA1';                                                     
                 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Get                                                                      
                 :      *                                                                          
                 :      * @param string $var Variable to get                                       
                 :      *                                                                          
                 :      * @return mixed Parameter if exists, else null                             
                 :      */                                                                         
                 :     public function __get($var)                                                 
                 :     {                                                                           
               8 :         $var = $this->prefixParameter($var);                                    
               8 :         if (array_key_exists($var, $this->parameters)) {                        
               7 :             return $this->parameters[$var];                                     
                 :         }                                                                       
                 :                                                                                 
               6 :         $method = 'get' . ucfirst($var);                                        
               6 :         if (method_exists($this, $method)) {                                    
               1 :             return $this->$method();                                            
                 :         }                                                                       
                 :                                                                                 
               5 :         return null;                                                            
                 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Set                                                                      
                 :      *                                                                          
                 :      * @param string $var Name of the variable                                  
                 :      * @param mixed  $val Value of the variable                                 
                 :      *                                                                          
                 :      * @return void                                                             
                 :      */                                                                         
                 :     public function __set($var, $val)                                           
                 :     {                                                                           
               6 :         $this->parameters[$this->prefixParameter($var)] = $val;                 
               6 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Offset exists                                                            
                 :      *                                                                          
                 :      * @param string $offset Name of the offset                                 
                 :      *                                                                          
                 :      * @return bool Offset exists or not                                        
                 :      */                                                                         
                 :     public function offsetExists($offset)                                       
                 :     {                                                                           
               3 :         return isset($this->parameters[$this->prefixParameter($offset)]);       
                 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Offset get                                                               
                 :      *                                                                          
                 :      * @param string $offset Name of the offset                                 
                 :      *                                                                          
                 :      * @return string Offset value                                              
                 :      */                                                                         
                 :     public function offsetGet($offset)                                          
                 :     {                                                                           
               3 :         return $this->parameters[$this->prefixParameter($offset)];              
                 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Offset set                                                               
                 :      *                                                                          
                 :      * @param string $offset Name of the offset                                 
                 :      * @param string $value  Value of the offset                                
                 :      *                                                                          
                 :      * @return void                                                             
                 :      */                                                                         
                 :     public function offsetSet($offset, $value)                                  
                 :     {                                                                           
               6 :         $this->parameters[$this->prefixParameter($offset)] = $value;            
               6 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Offset unset                                                             
                 :      *                                                                          
                 :      * @param string $offset Name of the offset                                 
                 :      *                                                                          
                 :      * @return void                                                             
                 :      */                                                                         
                 :     public function offsetUnset($offset)                                        
                 :     {                                                                           
               1 :         unset($this->parameters[$this->prefixParameter($offset)]);              
               1 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Count                                                                    
                 :      *                                                                          
                 :      * @return int Amount of parameters                                         
                 :      */                                                                         
                 :     public function count()                                                     
                 :     {                                                                           
               2 :         return count($this->parameters);                                        
                 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Get iterator                                                             
                 :      *                                                                          
                 :      * @return ArrayIterator Iterator for self::$parameters                     
                 :      */                                                                         
                 :     public function getIterator()                                               
                 :     {                                                                           
               1 :         return new ArrayIterator($this->parameters);                            
                 :     }                                                                           
                 :                                                                                 
                 :     /**                                                                         
                 :      * Prefix parameter                                                         
                 :      *                                                                          
                 :      * Prefixes a parameter name with oauth_ if it is a valid oauth paramter    
                 :      *                                                                          
                 :      * @param string $param Name of the parameter                               
                 :      *                                                                          
                 :      * @return string Prefix parameter                                          
                 :      */                                                                         
                 :     protected function prefixParameter($param)                                  
                 :     {                                                                           
              32 :         if (in_array($param, self::$oauthParams)) {                             
               7 :             $param = 'oauth_' . $param;                                         
               7 :         }                                                                       
                 :                                                                                 
              32 :         return $param;                                                          
                 :     }                                                                           
                 :                                                                                 
                 : }                                                                               
                 :                                                                                 
                 : ?>