Current file: htdocs/lib/Varien/Object.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
0.00%0.00%
0.00% 0 / 1
20.93%20.93%
20.93% 9 / 43 CRAP
22.55%22.55%
22.55% 53 / 235
 
Varien_Object
0.00%0.00%
0.00% 0 / 1
20.93%20.93%
20.93% 9 / 43
22.55%22.55%
22.55% 53 / 235
 __construct()
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 7 / 7
 _construct()
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 isDeleted($isDeleted=null)
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 5
 hasDataChanges()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 setIdFieldName($name)
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 2 / 2
 getIdFieldName()
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 1 / 1
 getId()
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 3
 setId($value)
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 5
 addData(array $arr)
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 4 / 4
 setData($key, $value=null)
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 6 / 6
 unsetData($key=null)
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 6
 getData($key='', $index=null)
0.00%0.00%
0.00% 0 / 1 161.73
20.59%20.59%
20.59% 7 / 34
 _getData($key)
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 1 / 1
 setDataUsingMethod($key, $args=array()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 3
 getDataUsingMethod($key, $args=null)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 2
 getDataSetDefault($key, $default)
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 4
 hasData($key='')
0.00%0.00%
0.00% 0 / 1 12
0.00%0.00%
0.00% 0 / 3
 __toArray(array $arrAttributes = array()
0.00%0.00%
0.00% 0 / 1 20
0.00%0.00%
0.00% 0 / 10
 toArray(array $arrAttributes = array()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 _prepareArray(&$arr, array $elements=array()
0.00%0.00%
0.00% 0 / 1 12
0.00%0.00%
0.00% 0 / 6
 __toXml(array $arrAttributes = array()
0.00%0.00%
0.00% 0 / 1 42
0.00%0.00%
0.00% 0 / 20
 toXml(array $arrAttributes = array()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 __toJson(array $arrAttributes = array()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 3
 toJson(array $arrAttributes = array()
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 toString($format='')
0.00%0.00%
0.00% 0 / 1 12
0.00%0.00%
0.00% 0 / 9
 __call($method, $args)
0.00%0.00%
0.00% 0 / 1 8.05
72.22%72.22%
72.22% 13 / 18
 __get($var)
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 2 / 2
 __set($var, $value)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 3
 isEmpty()
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 3
 _underscore($name)
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 5 / 5
 _camelize($name)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 serialize($attributes = array()
0.00%0.00%
0.00% 0 / 1 20
0.00%0.00%
0.00% 0 / 12
 getOrigData($key=null)
0.00%0.00%
0.00% 0 / 1 12
0.00%0.00%
0.00% 0 / 3
 setOrigData($key=null, $data=null)
0.00%0.00%
0.00% 0 / 1 2.03
80.00%80.00%
80.00% 4 / 5
 dataHasChangedFor($field)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 3
 setDataChanges($value)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 2
 debug($data=null, &$objects=array()
0.00%0.00%
0.00% 0 / 1 56
0.00%0.00%
0.00% 0 / 18
 offsetSet($offset, $value)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 2
 offsetExists($offset)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 1
 offsetUnset($offset)
0.00%0.00%
0.00% 0 / 1 2
0.00%0.00%
0.00% 0 / 2
 offsetGet($offset)
0.00%0.00%
0.00% 0 / 1 6
0.00%0.00%
0.00% 0 / 1
 isDirty($field=null)
0.00%0.00%
0.00% 0 / 1 12
0.00%0.00%
0.00% 0 / 5
 flagDirty($field, $flag=true)
0.00%0.00%
0.00% 0 / 1 20
0.00%0.00%
0.00% 0 / 10


       1                 : <?php                                                                                                                    
       2                 : /**                                                                                                                      
       3                 :  * Magento                                                                                                               
       4                 :  *                                                                                                                       
       5                 :  * NOTICE OF LICENSE                                                                                                     
       6                 :  *                                                                                                                       
       7                 :  * This source file is subject to the Open Software License (OSL 3.0)                                                    
       8                 :  * that is bundled with this package in the file LICENSE.txt.                                                            
       9                 :  * It is also available through the world-wide-web at this URL:                                                          
      10                 :  * http://opensource.org/licenses/osl-3.0.php                                                                            
      11                 :  * If you did not receive a copy of the license and are unable to                                                        
      12                 :  * obtain it through the world-wide-web, please send an email                                                            
      13                 :  * to license@magentocommerce.com so we can send you a copy immediately.                                                 
      14                 :  *                                                                                                                       
      15                 :  * DISCLAIMER                                                                                                            
      16                 :  *                                                                                                                       
      17                 :  * Do not edit or add to this file if you wish to upgrade Magento to newer                                               
      18                 :  * versions in the future. If you wish to customize Magento for your                                                     
      19                 :  * needs please refer to http://www.magentocommerce.com for more information.                                            
      20                 :  *                                                                                                                       
      21                 :  * @category   Varien                                                                                                    
      22                 :  * @package    Varien_Object                                                                                             
      23                 :  * @copyright  Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)                              
      24                 :  * @license    http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)                               
      25                 :  */                                                                                                                      
      26                 :                                                                                                                          
      27                 :                                                                                                                          
      28                 : /**                                                                                                                      
      29                 :  * Varien Object                                                                                                         
      30                 :  *                                                                                                                       
      31                 :  * @category   Varien                                                                                                    
      32                 :  * @package    Varien_Object                                                                                             
      33                 :  * @author      Magento Core Team <core@magentocommerce.com>                                                             
      34                 :  */                                                                                                                      
      35                 : class Varien_Object implements ArrayAccess                                                                               
      36                 : {                                                                                                                        
      37                 :                                                                                                                          
      38                 :     /**                                                                                                                  
      39                 :      * Object attributes                                                                                                 
      40                 :      *                                                                                                                   
      41                 :      * @var array                                                                                                        
      42                 :      */                                                                                                                  
      43                 :     protected $_data = array();                                                                                          
      44                 :                                                                                                                          
      45                 :     /**                                                                                                                  
      46                 :      * Data changes flag (true after setData|unsetData call)                                                             
      47                 :      * @var $_hasDataChange bool                                                                                         
      48                 :      */                                                                                                                  
      49                 :     protected $_hasDataChanges = false;                                                                                  
      50                 :                                                                                                                          
      51                 :     /**                                                                                                                  
      52                 :     * Original data that was loaded                                                                                      
      53                 :     *                                                                                                                    
      54                 :     * @var array                                                                                                         
      55                 :     */                                                                                                                   
      56                 :     protected $_origData;                                                                                                
      57                 :                                                                                                                          
      58                 :     /**                                                                                                                  
      59                 :      * Name of object id field                                                                                           
      60                 :      *                                                                                                                   
      61                 :      * @var string                                                                                                       
      62                 :      */                                                                                                                  
      63                 :     protected $_idFieldName = null;                                                                                      
      64                 :                                                                                                                          
      65                 :     /**                                                                                                                  
      66                 :      * Setter/Getter underscore transformation cache                                                                     
      67                 :      *                                                                                                                   
      68                 :      * @var array                                                                                                        
      69                 :      */                                                                                                                  
      70                 :     protected static $_underscoreCache = array();                                                                        
      71                 :                                                                                                                          
      72                 :     /**                                                                                                                  
      73                 :      * Object delete flag                                                                                                
      74                 :      *                                                                                                                   
      75                 :      * @var boolean                                                                                                      
      76                 :      */                                                                                                                  
      77                 :     protected $_isDeleted = false;                                                                                       
      78                 :                                                                                                                          
      79                 :     /**                                                                                                                  
      80                 :      * Constructor                                                                                                       
      81                 :      *                                                                                                                   
      82                 :      * By default is looking for first argument as array and assignes it as object attributes                            
      83                 :      * This behaviour may change in child classes                                                                        
      84                 :      *                                                                                                                   
      85                 :      */                                                                                                                  
      86                 :     public function __construct()                                                                                        
      87                 :     {                                                                                                                    
      88              17 :         $args = func_get_args();                                                                                         
      89              17 :         if (empty($args[0])) {                                                                                           
      90              17 :             $args[0] = array();                                                                                          
      91              17 :         }                                                                                                                
      92              17 :         $this->_data = $args[0];                                                                                         
      93                 :                                                                                                                          
      94              17 :         $this->_construct();                                                                                             
      95              17 :     }                                                                                                                    
      96                 :                                                                                                                          
      97                 :     /**                                                                                                                  
      98                 :      * Internal constructor not depended on params. Can be used for object initialization                                
      99                 :      */                                                                                                                  
     100                 :     protected function _construct()                                                                                      
     101                 :     {                                                                                                                    
     102              16 :     }                                                                                                                    
     103                 :                                                                                                                          
     104                 :     /**                                                                                                                  
     105                 :      * Set _isDeleted flag value (if $isDeleted param is defined) and return current flag value                          
     106                 :      *                                                                                                                   
     107                 :      * @param boolean $isDeleted                                                                                         
     108                 :      * @return boolean                                                                                                   
     109                 :      */                                                                                                                  
     110                 :     public function isDeleted($isDeleted=null)                                                                           
     111                 :     {                                                                                                                    
     112               0 :         $result = $this->_isDeleted;                                                                                     
     113               0 :         if (!is_null($isDeleted)) {                                                                                      
     114               0 :             $this->_isDeleted = $isDeleted;                                                                              
     115               0 :         }                                                                                                                
     116               0 :         return $result;                                                                                                  
     117                 :     }                                                                                                                    
     118                 :                                                                                                                          
     119                 :     /**                                                                                                                  
     120                 :      * Get data change status                                                                                            
     121                 :      *                                                                                                                   
     122                 :      * @return bool                                                                                                      
     123                 :      */                                                                                                                  
     124                 :     public function hasDataChanges()                                                                                     
     125                 :     {                                                                                                                    
     126               0 :         return $this->_hasDataChanges;                                                                                   
     127                 :     }                                                                                                                    
     128                 :                                                                                                                          
     129                 :     /**                                                                                                                  
     130                 :      * set name of object id field                                                                                       
     131                 :      *                                                                                                                   
     132                 :      * @param   string $name                                                                                             
     133                 :      * @return  Varien_Object                                                                                            
     134                 :      */                                                                                                                  
     135                 :     public function setIdFieldName($name)                                                                                
     136                 :     {                                                                                                                    
     137              15 :         $this->_idFieldName = $name;                                                                                     
     138              15 :         return $this;                                                                                                    
     139                 :     }                                                                                                                    
     140                 :                                                                                                                          
     141                 :     /**                                                                                                                  
     142                 :      * Retrieve name of object id field                                                                                  
     143                 :      *                                                                                                                   
     144                 :      * @param   string $name                                                                                             
     145                 :      * @return  Varien_Object                                                                                            
     146                 :      */                                                                                                                  
     147                 :     public function getIdFieldName()                                                                                     
     148                 :     {                                                                                                                    
     149              15 :         return $this->_idFieldName;                                                                                      
     150                 :     }                                                                                                                    
     151                 :                                                                                                                          
     152                 :     /**                                                                                                                  
     153                 :      * Retrieve object id                                                                                                
     154                 :      *                                                                                                                   
     155                 :      * @return mixed                                                                                                     
     156                 :      */                                                                                                                  
     157                 :     public function getId()                                                                                              
     158                 :     {                                                                                                                    
     159               0 :         if ($this->getIdFieldName()) {                                                                                   
     160               0 :             return $this->_getData($this->getIdFieldName());                                                             
     161                 :         }                                                                                                                
     162               0 :         return $this->_getData('id');                                                                                    
     163                 :     }                                                                                                                    
     164                 :                                                                                                                          
     165                 :     /**                                                                                                                  
     166                 :      * Set object id field value                                                                                         
     167                 :      *                                                                                                                   
     168                 :      * @param   mixed $value                                                                                             
     169                 :      * @return  Varien_Object                                                                                            
     170                 :      */                                                                                                                  
     171                 :     public function setId($value)                                                                                        
     172                 :     {                                                                                                                    
     173               0 :         if ($this->getIdFieldName()) {                                                                                   
     174               0 :             $this->setData($this->getIdFieldName(), $value);                                                             
     175               0 :         } else {                                                                                                         
     176               0 :             $this->setData('id', $value);                                                                                
     177                 :         }                                                                                                                
     178               0 :         return $this;                                                                                                    
     179                 :     }                                                                                                                    
     180                 :                                                                                                                          
     181                 :     /**                                                                                                                  
     182                 :      * Add data to the object.                                                                                           
     183                 :      *                                                                                                                   
     184                 :      * Retains previous data in the object.                                                                              
     185                 :      *                                                                                                                   
     186                 :      * @param array $arr                                                                                                 
     187                 :      * @return Varien_Object                                                                                             
     188                 :      */                                                                                                                  
     189                 :     public function addData(array $arr)                                                                                  
     190                 :     {                                                                                                                    
     191              16 :         foreach($arr as $index=>$value) {                                                                                
     192              16 :             $this->setData($index, $value);                                                                              
     193              16 :         }                                                                                                                
     194              16 :         return $this;                                                                                                    
     195                 :     }                                                                                                                    
     196                 :                                                                                                                          
     197                 :     /**                                                                                                                  
     198                 :      * Overwrite data in the object.                                                                                     
     199                 :      *                                                                                                                   
     200                 :      * $key can be string or array.                                                                                      
     201                 :      * If $key is string, the attribute value will be overwritten by $value                                              
     202                 :      *                                                                                                                   
     203                 :      * If $key is an array, it will overwrite all the data in the object.                                                
     204                 :      *                                                                                                                   
     205                 :      * @param string|array $key                                                                                          
     206                 :      * @param mixed $value                                                                                               
     207                 :      * @return Varien_Object                                                                                             
     208                 :      */                                                                                                                  
     209                 :     public function setData($key, $value=null)                                                                           
     210                 :     {                                                                                                                    
     211              16 :         $this->_hasDataChanges = true;                                                                                   
     212              16 :         if(is_array($key)) {                                                                                             
     213              16 :             $this->_data = $key;                                                                                         
     214              16 :         } else {                                                                                                         
     215              16 :             $this->_data[$key] = $value;                                                                                 
     216                 :         }                                                                                                                
     217              16 :         return $this;                                                                                                    
     218                 :     }                                                                                                                    
     219                 :                                                                                                                          
     220                 :     /**                                                                                                                  
     221                 :      * Unset data from the object.                                                                                       
     222                 :      *                                                                                                                   
     223                 :      * $key can be a string only. Array will be ignored.                                                                 
     224                 :      *                                                                                                                   
     225                 :      * @param string $key                                                                                                
     226                 :      * @return Varien_Object                                                                                             
     227                 :      */                                                                                                                  
     228                 :     public function unsetData($key=null)                                                                                 
     229                 :     {                                                                                                                    
     230               0 :         $this->_hasDataChanges = true;                                                                                   
     231               0 :         if (is_null($key)) {                                                                                             
     232               0 :             $this->_data = array();                                                                                      
     233               0 :         } else {                                                                                                         
     234               0 :             unset($this->_data[$key]);                                                                                   
     235                 :         }                                                                                                                
     236               0 :         return $this;                                                                                                    
     237                 :     }                                                                                                                    
     238                 :                                                                                                                          
     239                 :     /**                                                                                                                  
     240                 :      * Retrieves data from the object                                                                                    
     241                 :      *                                                                                                                   
     242                 :      * If $key is empty will return all the data as an array                                                             
     243                 :      * Otherwise it will return value of the attribute specified by $key                                                 
     244                 :      *                                                                                                                   
     245                 :      * If $index is specified it will assume that attribute data is an array                                             
     246                 :      * and retrieve corresponding member.                                                                                
     247                 :      *                                                                                                                   
     248                 :      * @param string $key                                                                                                
     249                 :      * @param string|int $index                                                                                          
     250                 :      * @return mixed                                                                                                     
     251                 :      */                                                                                                                  
     252                 :     public function getData($key='', $index=null)                                                                        
     253                 :     {                                                                                                                    
     254              16 :         if (''===$key) {                                                                                                 
     255               0 :             return $this->_data;                                                                                         
     256                 :         }                                                                                                                
     257                 :                                                                                                                          
     258              16 :         $default = null;                                                                                                 
     259                 :                                                                                                                          
     260                 :         // accept a/b/c as ['a']['b']['c']                                                                               
     261              16 :         if (strpos($key,'/')) {                                                                                          
     262               0 :             $keyArr = explode('/', $key);                                                                                
     263               0 :             $data = $this->_data;                                                                                        
     264               0 :             foreach ($keyArr as $i=>$k) {                                                                                
     265               0 :                 if ($k==='') {                                                                                           
     266               0 :                     return $default;                                                                                     
     267                 :                 }                                                                                                        
     268               0 :                 if (is_array($data)) {                                                                                   
     269               0 :                     if (!isset($data[$k])) {                                                                             
     270               0 :                         return $default;                                                                                 
     271                 :                     }                                                                                                    
     272               0 :                     $data = $data[$k];                                                                                   
     273               0 :                 } elseif ($data instanceof Varien_Object) {                                                              
     274               0 :                     $data = $data->getData($k);                                                                          
     275               0 :                 } else {                                                                                                 
     276               0 :                     return $default;                                                                                     
     277                 :                 }                                                                                                        
     278               0 :             }                                                                                                            
     279               0 :             return $data;                                                                                                
     280                 :         }                                                                                                                
     281                 :                                                                                                                          
     282                 :         // legacy functionality for $index                                                                               
     283              16 :         if (isset($this->_data[$key])) {                                                                                 
     284              16 :             if (is_null($index)) {                                                                                       
     285              16 :                 return $this->_data[$key];                                                                               
     286                 :             }                                                                                                            
     287                 :                                                                                                                          
     288               0 :             $value = $this->_data[$key];                                                                                 
     289               0 :             if (is_array($value)) {                                                                                      
     290                 :                 //if (isset($value[$index]) && (!empty($value[$index]) || strlen($value[$index]) > 0)) {                 
     291                 :                 /**                                                                                                      
     292                 :                  * If we have any data, even if it empty - we should use it, anyway                                      
     293                 :                  */                                                                                                      
     294               0 :                 if (isset($value[$index])) {                                                                             
     295               0 :                     return $value[$index];                                                                               
     296                 :                 }                                                                                                        
     297               0 :                 return null;                                                                                             
     298               0 :             } elseif (is_string($value)) {                                                                               
     299               0 :                 $arr = explode("\n", $value);                                                                            
     300               0 :                 return (isset($arr[$index]) && (!empty($arr[$index]) || strlen($arr[$index]) > 0)) ? $arr[$index] : null;
     301               0 :             } elseif ($value instanceof Varien_Object) {                                                                 
     302               0 :                 return $value->getData($index);                                                                          
     303                 :             }                                                                                                            
     304               0 :             return $default;                                                                                             
     305                 :         }                                                                                                                
     306               2 :         return $default;                                                                                                 
     307                 :     }                                                                                                                    
     308                 :                                                                                                                          
     309                 :     /**                                                                                                                  
     310                 :      * Get value from _data array without parse key                                                                      
     311                 :      *                                                                                                                   
     312                 :      * @param   string $key                                                                                              
     313                 :      * @return  mixed                                                                                                    
     314                 :      */                                                                                                                  
     315                 :     protected function _getData($key)                                                                                    
     316                 :     {                                                                                                                    
     317              17 :         return isset($this->_data[$key]) ? $this->_data[$key] : null;                                                    
     318                 :     }                                                                                                                    
     319                 :                                                                                                                          
     320                 :     /**                                                                                                                  
     321                 :      * Set object data with calling setter method                                                                        
     322                 :      *                                                                                                                   
     323                 :      * @param string $key                                                                                                
     324                 :      * @param mixed $args                                                                                                
     325                 :      * @return Varien_Object                                                                                             
     326                 :      */                                                                                                                  
     327                 :     public function setDataUsingMethod($key, $args=array())                                                              
     328                 :     {                                                                                                                    
     329               0 :         $method = 'set'.$this->_camelize($key);                                                                          
     330               0 :         $this->$method($args);                                                                                           
     331               0 :         return $this;                                                                                                    
     332                 :     }                                                                                                                    
     333                 :                                                                                                                          
     334                 :     /**                                                                                                                  
     335                 :      * Get object data by key with calling getter method                                                                 
     336                 :      *                                                                                                                   
     337                 :      * @param string $key                                                                                                
     338                 :      * @param mixed $args                                                                                                
     339                 :      * @return mixed                                                                                                     
     340                 :      */                                                                                                                  
     341                 :     public function getDataUsingMethod($key, $args=null)                                                                 
     342                 :     {                                                                                                                    
     343               0 :         $method = 'get'.$this->_camelize($key);                                                                          
     344               0 :         return $this->$method($args);                                                                                    
     345                 :     }                                                                                                                    
     346                 :                                                                                                                          
     347                 :     /**                                                                                                                  
     348                 :      * Fast get data or set default if value is not available                                                            
     349                 :      *                                                                                                                   
     350                 :      * @param string $key                                                                                                
     351                 :      * @param mixed $default                                                                                             
     352                 :      * @return mixed                                                                                                     
     353                 :      */                                                                                                                  
     354                 :     public function getDataSetDefault($key, $default)                                                                    
     355                 :     {                                                                                                                    
     356               0 :         if (!isset($this->_data[$key])) {                                                                                
     357               0 :             $this->_data[$key] = $default;                                                                               
     358               0 :         }                                                                                                                
     359               0 :         return $this->_data[$key];                                                                                       
     360                 :     }                                                                                                                    
     361                 :                                                                                                                          
     362                 :     /**                                                                                                                  
     363                 :      * If $key is empty, checks whether there's any data in the object                                                   
     364                 :      * Otherwise checks if the specified attribute is set.                                                               
     365                 :      *                                                                                                                   
     366                 :      * @param string $key                                                                                                
     367                 :      * @return boolean                                                                                                   
     368                 :      */                                                                                                                  
     369                 :     public function hasData($key='')                                                                                     
     370                 :     {                                                                                                                    
     371               0 :         if (empty($key) || !is_string($key)) {                                                                           
     372               0 :             return !empty($this->_data);                                                                                 
     373                 :         }                                                                                                                
     374               0 :         return array_key_exists($key, $this->_data);                                                                     
     375                 :     }                                                                                                                    
     376                 :                                                                                                                          
     377                 :     /**                                                                                                                  
     378                 :      * Convert object attributes to array                                                                                
     379                 :      *                                                                                                                   
     380                 :      * @param  array $arrAttributes array of required attributes                                                         
     381                 :      * @return array                                                                                                     
     382                 :      */                                                                                                                  
     383                 :     public function __toArray(array $arrAttributes = array())                                                            
     384                 :     {                                                                                                                    
     385               0 :         if (empty($arrAttributes)) {                                                                                     
     386               0 :             return $this->_data;                                                                                         
     387                 :         }                                                                                                                
     388                 :                                                                                                                          
     389               0 :         $arrRes = array();                                                                                               
     390               0 :         foreach ($arrAttributes as $attribute) {                                                                         
     391               0 :             if (isset($this->_data[$attribute])) {                                                                       
     392               0 :                 $arrRes[$attribute] = $this->_data[$attribute];                                                          
     393               0 :             }                                                                                                            
     394                 :             else {                                                                                                       
     395               0 :                 $arrRes[$attribute] = null;                                                                              
     396                 :             }                                                                                                            
     397               0 :         }                                                                                                                
     398               0 :         return $arrRes;                                                                                                  
     399                 :     }                                                                                                                    
     400                 :                                                                                                                          
     401                 :     /**                                                                                                                  
     402                 :      * Public wrapper for __toArray                                                                                      
     403                 :      *                                                                                                                   
     404                 :      * @param array $arrAttributes                                                                                       
     405                 :      * @return array                                                                                                     
     406                 :      */                                                                                                                  
     407                 :     public function toArray(array $arrAttributes = array())                                                              
     408                 :     {                                                                                                                    
     409               0 :         return $this->__toArray($arrAttributes);                                                                         
     410                 :     }                                                                                                                    
     411                 :                                                                                                                          
     412                 :     /**                                                                                                                  
     413                 :      * Set required array elements                                                                                       
     414                 :      *                                                                                                                   
     415                 :      * @param   array $arr                                                                                               
     416                 :      * @param   array $elements                                                                                          
     417                 :      * @return  array                                                                                                    
     418                 :      */                                                                                                                  
     419                 :     protected function _prepareArray(&$arr, array $elements=array())                                                     
     420                 :     {                                                                                                                    
     421               0 :         foreach ($elements as $element) {                                                                                
     422               0 :             if (!isset($arr[$element])) {                                                                                
     423               0 :                 $arr[$element] = null;                                                                                   
     424               0 :             }                                                                                                            
     425               0 :         }                                                                                                                
     426               0 :         return $arr;                                                                                                     
     427                 :     }                                                                                                                    
     428                 :                                                                                                                          
     429                 :     /**                                                                                                                  
     430                 :      * Convert object attributes to XML                                                                                  
     431                 :      *                                                                                                                   
     432                 :      * @param  array $arrAttributes array of required attributes                                                         
     433                 :      * @param string $rootName name of the root element                                                                  
     434                 :      * @return string                                                                                                    
     435                 :      */                                                                                                                  
     436                 :     protected function __toXml(array $arrAttributes = array(), $rootName = 'item', $addOpenTag=false, $addCdata=true)    
     437                 :     {                                                                                                                    
     438               0 :         $xml = '';                                                                                                       
     439               0 :         if ($addOpenTag) {                                                                                               
     440               0 :             $xml.= '<?xml version="1.0" encoding="UTF-8"?>'."\n";                                                        
     441               0 :         }                                                                                                                
     442               0 :         if (!empty($rootName)) {                                                                                         
     443               0 :             $xml.= '<'.$rootName.'>'."\n";                                                                               
     444               0 :         }                                                                                                                
     445               0 :         $xmlModel = new Varien_Simplexml_Element('<node></node>');                                                       
     446               0 :         $arrData = $this->toArray($arrAttributes);                                                                       
     447               0 :         foreach ($arrData as $fieldName => $fieldValue) {                                                                
     448               0 :             if ($addCdata === true) {                                                                                    
     449               0 :                 $fieldValue = "<![CDATA[$fieldValue]]>";                                                                 
     450               0 :             } else {                                                                                                     
     451               0 :                 $fieldValue = $xmlModel->xmlentities($fieldValue);                                                       
     452                 :             }                                                                                                            
     453               0 :             $xml.= "<$fieldName>$fieldValue</$fieldName>"."\n";                                                          
     454               0 :         }                                                                                                                
     455               0 :         if (!empty($rootName)) {                                                                                         
     456               0 :             $xml.= '</'.$rootName.'>'."\n";                                                                              
     457               0 :         }                                                                                                                
     458               0 :         return $xml;                                                                                                     
     459                 :     }                                                                                                                    
     460                 :                                                                                                                          
     461                 :     /**                                                                                                                  
     462                 :      * Public wrapper for __toXml                                                                                        
     463                 :      *                                                                                                                   
     464                 :      * @param array $arrAttributes                                                                                       
     465                 :      * @param string $rootName                                                                                           
     466                 :      * @return string                                                                                                    
     467                 :      */                                                                                                                  
     468                 :     public function toXml(array $arrAttributes = array(), $rootName = 'item', $addOpenTag=false, $addCdata=true)         
     469                 :     {                                                                                                                    
     470               0 :         return $this->__toXml($arrAttributes, $rootName, $addOpenTag, $addCdata);                                        
     471                 :     }                                                                                                                    
     472                 :                                                                                                                          
     473                 :     /**                                                                                                                  
     474                 :      * Convert object attributes to JSON                                                                                 
     475                 :      *                                                                                                                   
     476                 :      * @param  array $arrAttributes array of required attributes                                                         
     477                 :      * @return string                                                                                                    
     478                 :      */                                                                                                                  
     479                 :     protected function __toJson(array $arrAttributes = array())                                                          
     480                 :     {                                                                                                                    
     481               0 :         $arrData = $this->toArray($arrAttributes);                                                                       
     482               0 :         $json = Zend_Json::encode($arrData);                                                                             
     483               0 :         return $json;                                                                                                    
     484                 :     }                                                                                                                    
     485                 :                                                                                                                          
     486                 :     /**                                                                                                                  
     487                 :      * Public wrapper for __toJson                                                                                       
     488                 :      *                                                                                                                   
     489                 :      * @param array $arrAttributes                                                                                       
     490                 :      * @return string                                                                                                    
     491                 :      */                                                                                                                  
     492                 :     public function toJson(array $arrAttributes = array())                                                               
     493                 :     {                                                                                                                    
     494               0 :         return $this->__toJson($arrAttributes);                                                                          
     495                 :     }                                                                                                                    
     496                 :                                                                                                                          
     497                 :     /**                                                                                                                  
     498                 :      * Convert object attributes to string                                                                               
     499                 :      *                                                                                                                   
     500                 :      * @param  array  $arrAttributes array of required attributes                                                        
     501                 :      * @param  string $valueSeparator                                                                                    
     502                 :      * @return string                                                                                                    
     503                 :      */                                                                                                                  
     504                 : //    public function __toString(array $arrAttributes = array(), $valueSeparator=',')                                    
     505                 : //    {                                                                                                                  
     506                 : //        $arrData = $this->toArray($arrAttributes);                                                                     
     507                 : //        return implode($valueSeparator, $arrData);                                                                     
     508                 : //    }                                                                                                                  
     509                 :                                                                                                                          
     510                 :     /**                                                                                                                  
     511                 :      * Public wrapper for __toString                                                                                     
     512                 :      *                                                                                                                   
     513                 :      * Will use $format as an template and substitute {{key}} for attributes                                             
     514                 :      *                                                                                                                   
     515                 :      * @param string $format                                                                                             
     516                 :      * @return string                                                                                                    
     517                 :      */                                                                                                                  
     518                 :     public function toString($format='')                                                                                 
     519                 :     {                                                                                                                    
     520               0 :         if (empty($format)) {                                                                                            
     521               0 :             $str = implode(', ', $this->getData());                                                                      
     522               0 :         } else {                                                                                                         
     523               0 :             preg_match_all('/\{\{([a-z0-9_]+)\}\}/is', $format, $matches);                                               
     524               0 :             foreach ($matches[1] as $var) {                                                                              
     525               0 :                 $format = str_replace('{{'.$var.'}}', $this->getData($var), $format);                                    
     526               0 :             }                                                                                                            
     527               0 :             $str = $format;                                                                                              
     528                 :         }                                                                                                                
     529               0 :         return $str;                                                                                                     
     530                 :     }                                                                                                                    
     531                 :                                                                                                                          
     532                 :     /**                                                                                                                  
     533                 :      * Set/Get attribute wrapper                                                                                         
     534                 :      *                                                                                                                   
     535                 :      * @param   string $method                                                                                           
     536                 :      * @param   array $args                                                                                              
     537                 :      * @return  mixed                                                                                                    
     538                 :      */                                                                                                                  
     539                 :     public function __call($method, $args)                                                                               
     540                 :     {                                                                                                                    
     541              16 :         switch (substr($method, 0, 3)) {                                                                                 
     542              16 :             case 'get' :                                                                                                 
     543                 :                 //Varien_Profiler::start('GETTER: '.get_class($this).'::'.$method);                                      
     544              16 :                 $key = $this->_underscore(substr($method,3));                                                            
     545              16 :                 $data = $this->getData($key, isset($args[0]) ? $args[0] : null);                                         
     546                 :                 //Varien_Profiler::stop('GETTER: '.get_class($this).'::'.$method);                                       
     547              16 :                 return $data;                                                                                            
     548                 :                                                                                                                          
     549              15 :             case 'set' :                                                                                                 
     550                 :                 //Varien_Profiler::start('SETTER: '.get_class($this).'::'.$method);                                      
     551               2 :                 $key = $this->_underscore(substr($method,3));                                                            
     552               2 :                 $result = $this->setData($key, isset($args[0]) ? $args[0] : null);                                       
     553                 :                 //Varien_Profiler::stop('SETTER: '.get_class($this).'::'.$method);                                       
     554               2 :                 return $result;                                                                                          
     555                 :                                                                                                                          
     556              15 :             case 'uns' :                                                                                                 
     557                 :                 //Varien_Profiler::start('UNS: '.get_class($this).'::'.$method);                                         
     558               0 :                 $key = $this->_underscore(substr($method,3));                                                            
     559               0 :                 $result = $this->unsetData($key);                                                                        
     560                 :                 //Varien_Profiler::stop('UNS: '.get_class($this).'::'.$method);                                          
     561               0 :                 return $result;                                                                                          
     562                 :                                                                                                                          
     563              15 :             case 'has' :                                                                                                 
     564                 :                 //Varien_Profiler::start('HAS: '.get_class($this).'::'.$method);                                         
     565              15 :                 $key = $this->_underscore(substr($method,3));                                                            
     566                 :                 //Varien_Profiler::stop('HAS: '.get_class($this).'::'.$method);                                          
     567              15 :                 return isset($this->_data[$key]);                                                                        
     568               0 :         }                                                                                                                
     569               0 :         throw new Varien_Exception("Invalid method ".get_class($this)."::".$method."(".print_r($args,1).")");            
     570                 :     }                                                                                                                    
     571                 :                                                                                                                          
     572                 :     /**                                                                                                                  
     573                 :      * Attribute getter (deprecated)                                                                                     
     574                 :      *                                                                                                                   
     575                 :      * @param string $var                                                                                                
     576                 :      * @return mixed                                                                                                     
     577                 :      */                                                                                                                  
     578                 :                                                                                                                          
     579                 :     public function __get($var)                                                                                          
     580                 :     {                                                                                                                    
     581               2 :         $var = $this->_underscore($var);                                                                                 
     582               2 :         return $this->getData($var);                                                                                     
     583                 :     }                                                                                                                    
     584                 :                                                                                                                          
     585                 :     /**                                                                                                                  
     586                 :      * Attribute setter (deprecated)                                                                                     
     587                 :      *                                                                                                                   
     588                 :      * @param string $var                                                                                                
     589                 :      * @param mixed $value                                                                                               
     590                 :      */                                                                                                                  
     591                 :     public function __set($var, $value)                                                                                  
     592                 :     {                                                                                                                    
     593               0 :         $var = $this->_underscore($var);                                                                                 
     594               0 :         $this->setData($var, $value);                                                                                    
     595               0 :     }                                                                                                                    
     596                 :                                                                                                                          
     597                 :     /**                                                                                                                  
     598                 :      * checks whether the object is empty                                                                                
     599                 :      *                                                                                                                   
     600                 :      * @return boolean                                                                                                   
     601                 :      */                                                                                                                  
     602                 :     public function isEmpty()                                                                                            
     603                 :     {                                                                                                                    
     604               0 :         if (empty($this->_data)) {                                                                                       
     605               0 :             return true;                                                                                                 
     606                 :         }                                                                                                                
     607               0 :         return false;                                                                                                    
     608                 :     }                                                                                                                    
     609                 :                                                                                                                          
     610                 :     /**                                                                                                                  
     611                 :      * Converts field names for setters and geters                                                                       
     612                 :      *                                                                                                                   
     613                 :      * $this->setMyField($value) === $this->setData('my_field', $value)                                                  
     614                 :      * Uses cache to eliminate unneccessary preg_replace                                                                 
     615                 :      *                                                                                                                   
     616                 :      * @param string $name                                                                                               
     617                 :      * @return string                                                                                                    
     618                 :      */                                                                                                                  
     619                 :     protected function _underscore($name)                                                                                
     620                 :     {                                                                                                                    
     621              16 :         if (isset(self::$_underscoreCache[$name])) {                                                                     
     622              16 :             return self::$_underscoreCache[$name];                                                                       
     623                 :         }                                                                                                                
     624                 :         #Varien_Profiler::start('underscore');                                                                           
     625               5 :         $result = strtolower(preg_replace('/(.)([A-Z])/', "$1_$2", $name));                                              
     626                 :         #Varien_Profiler::stop('underscore');                                                                            
     627               5 :         self::$_underscoreCache[$name] = $result;                                                                        
     628               5 :         return $result;                                                                                                  
     629                 :     }                                                                                                                    
     630                 :                                                                                                                          
     631                 :     protected function _camelize($name)                                                                                  
     632                 :     {                                                                                                                    
     633               0 :         return uc_words($name, '');                                                                                      
     634                 :     }                                                                                                                    
     635                 :                                                                                                                          
     636                 :     /**                                                                                                                  
     637                 :      * serialize object attributes                                                                                       
     638                 :      *                                                                                                                   
     639                 :      * @param   array $attributes                                                                                        
     640                 :      * @param   string $valueSeparator                                                                                   
     641                 :      * @param   string $fieldSeparator                                                                                   
     642                 :      * @param   string $quote                                                                                            
     643                 :      * @return  string                                                                                                   
     644                 :      */                                                                                                                  
     645                 :     public function serialize($attributes = array(), $valueSeparator='=', $fieldSeparator=' ', $quote='"')               
     646                 :     {                                                                                                                    
     647               0 :         $res  = '';                                                                                                      
     648               0 :         $data = array();                                                                                                 
     649               0 :         if (empty($attributes)) {                                                                                        
     650               0 :             $attributes = array_keys($this->_data);                                                                      
     651               0 :         }                                                                                                                
     652                 :                                                                                                                          
     653               0 :         foreach ($this->_data as $key => $value) {                                                                       
     654               0 :             if (in_array($key, $attributes)) {                                                                           
     655               0 :                 $data[] = $key . $valueSeparator . $quote . $value . $quote;                                             
     656               0 :             }                                                                                                            
     657               0 :         }                                                                                                                
     658               0 :         $res = implode($fieldSeparator, $data);                                                                          
     659               0 :         return $res;                                                                                                     
     660                 :     }                                                                                                                    
     661                 :                                                                                                                          
     662                 :     /**                                                                                                                  
     663                 :      * Get object loaded data (original data)                                                                            
     664                 :      *                                                                                                                   
     665                 :      * @param string $key                                                                                                
     666                 :      * @return mixed                                                                                                     
     667                 :      */                                                                                                                  
     668                 :     public function getOrigData($key=null)                                                                               
     669                 :     {                                                                                                                    
     670               0 :         if (is_null($key)) {                                                                                             
     671               0 :             return $this->_origData;                                                                                     
     672                 :         }                                                                                                                
     673               0 :         return isset($this->_origData[$key]) ? $this->_origData[$key] : null;                                            
     674                 :     }                                                                                                                    
     675                 :                                                                                                                          
     676                 :     /**                                                                                                                  
     677                 :      * Initialize object original data                                                                                   
     678                 :      *                                                                                                                   
     679                 :      * @param string $key                                                                                                
     680                 :      * @param mixed $data                                                                                                
     681                 :      * @return Varien_Object                                                                                             
     682                 :      */                                                                                                                  
     683                 :     public function setOrigData($key=null, $data=null)                                                                   
     684                 :     {                                                                                                                    
     685              15 :         if (is_null($key)) {                                                                                             
     686              15 :             $this->_origData = $this->_data;                                                                             
     687              15 :         } else {                                                                                                         
     688               0 :             $this->_origData[$key] = $data;                                                                              
     689                 :         }                                                                                                                
     690              15 :         return $this;                                                                                                    
     691                 :     }                                                                                                                    
     692                 :                                                                                                                          
     693                 :     /**                                                                                                                  
     694                 :      * Compare object data with original data                                                                            
     695                 :      *                                                                                                                   
     696                 :      * @param string $field                                                                                              
     697                 :      * @return boolean                                                                                                   
     698                 :      */                                                                                                                  
     699                 :     public function dataHasChangedFor($field)                                                                            
     700                 :     {                                                                                                                    
     701               0 :         $newData = $this->getData($field);                                                                               
     702               0 :         $origData = $this->getOrigData($field);                                                                          
     703               0 :         return $newData!=$origData;                                                                                      
     704                 :     }                                                                                                                    
     705                 :                                                                                                                          
     706                 :     /**                                                                                                                  
     707                 :      * Clears data changes status                                                                                        
     708                 :      *                                                                                                                   
     709                 :      * @param boolean $value                                                                                             
     710                 :      * @return Varien_Object                                                                                             
     711                 :      */                                                                                                                  
     712                 :     public function setDataChanges($value)                                                                               
     713                 :     {                                                                                                                    
     714               0 :         $this->_hasDataChanges = (bool)$value;                                                                           
     715               0 :         return $this;                                                                                                    
     716                 :     }                                                                                                                    
     717                 :                                                                                                                          
     718                 :     /**                                                                                                                  
     719                 :      * Present object data as string in debug mode                                                                       
     720                 :      *                                                                                                                   
     721                 :      * @param mixed $data                                                                                                
     722                 :      * @param array $objects                                                                                             
     723                 :      * @return string                                                                                                    
     724                 :      */                                                                                                                  
     725                 :     public function debug($data=null, &$objects=array())                                                                 
     726                 :     {                                                                                                                    
     727               0 :         if (is_null($data)) {                                                                                            
     728               0 :             $hash = spl_object_hash($this);                                                                              
     729               0 :             if (!empty($objects[$hash])) {                                                                               
     730               0 :                 return '*** RECURSION ***';                                                                              
     731                 :             }                                                                                                            
     732               0 :             $objects[$hash] = true;                                                                                      
     733               0 :             $data = $this->getData();                                                                                    
     734               0 :         }                                                                                                                
     735               0 :         $debug = array();                                                                                                
     736               0 :         foreach ($data as $key=>$value) {                                                                                
     737               0 :             if (is_scalar($value)) {                                                                                     
     738               0 :                 $debug[$key] = $value;                                                                                   
     739               0 :             } elseif (is_array($value)) {                                                                                
     740               0 :                 $debug[$key] = $this->debug($value, $objects);                                                           
     741               0 :             } elseif ($value instanceof Varien_Object) {                                                                 
     742               0 :                 $debug[$key.' ('.get_class($value).')'] = $value->debug(null, $objects);                                 
     743               0 :             }                                                                                                            
     744               0 :         }                                                                                                                
     745               0 :         return $debug;                                                                                                   
     746                 :     }                                                                                                                    
     747                 :                                                                                                                          
     748                 :     /**                                                                                                                  
     749                 :      * Implementation of ArrayAccess::offsetSet()                                                                        
     750                 :      *                                                                                                                   
     751                 :      * @link http://www.php.net/manual/en/arrayaccess.offsetset.php                                                      
     752                 :      * @param string $offset                                                                                             
     753                 :      * @param mixed $value                                                                                               
     754                 :      */                                                                                                                  
     755                 :     public function offsetSet($offset, $value)                                                                           
     756                 :     {                                                                                                                    
     757               0 :         $this->_data[$offset] = $value;                                                                                  
     758               0 :     }                                                                                                                    
     759                 :                                                                                                                          
     760                 :     /**                                                                                                                  
     761                 :      * Implementation of ArrayAccess::offsetExists()                                                                     
     762                 :      *                                                                                                                   
     763                 :      * @link http://www.php.net/manual/en/arrayaccess.offsetexists.php                                                   
     764                 :      * @param string $offset                                                                                             
     765                 :      * @return boolean                                                                                                   
     766                 :      */                                                                                                                  
     767                 :     public function offsetExists($offset)                                                                                
     768                 :     {                                                                                                                    
     769               0 :         return isset($this->_data[$offset]);                                                                             
     770                 :     }                                                                                                                    
     771                 :                                                                                                                          
     772                 :     /**                                                                                                                  
     773                 :      * Implementation of ArrayAccess::offsetUnset()                                                                      
     774                 :      *                                                                                                                   
     775                 :      * @link http://www.php.net/manual/en/arrayaccess.offsetunset.php                                                    
     776                 :      * @param string $offset                                                                                             
     777                 :      */                                                                                                                  
     778                 :     public function offsetUnset($offset)                                                                                 
     779                 :     {                                                                                                                    
     780               0 :         unset($this->_data[$offset]);                                                                                    
     781               0 :     }                                                                                                                    
     782                 :                                                                                                                          
     783                 :     /**                                                                                                                  
     784                 :      * Implementation of ArrayAccess::offsetGet()                                                                        
     785                 :      *                                                                                                                   
     786                 :      * @link http://www.php.net/manual/en/arrayaccess.offsetget.php                                                      
     787                 :      * @param string $offset                                                                                             
     788                 :      * @return mixed                                                                                                     
     789                 :      */                                                                                                                  
     790                 :     public function offsetGet($offset)                                                                                   
     791                 :     {                                                                                                                    
     792               0 :         return isset($this->_data[$offset]) ? $this->_data[$offset] : null;                                              
     793                 :     }                                                                                                                    
     794                 :                                                                                                                          
     795                 :                                                                                                                          
     796                 :     /**                                                                                                                  
     797                 :      * Enter description here...                                                                                         
     798                 :      *                                                                                                                   
     799                 :      * @param string $field                                                                                              
     800                 :      * @return boolean                                                                                                   
     801                 :      */                                                                                                                  
     802                 :     public function isDirty($field=null)                                                                                 
     803                 :     {                                                                                                                    
     804               0 :         if (empty($this->_dirty)) {                                                                                      
     805               0 :             return false;                                                                                                
     806                 :         }                                                                                                                
     807               0 :         if (is_null($field)) {                                                                                           
     808               0 :             return true;                                                                                                 
     809                 :         }                                                                                                                
     810               0 :         return isset($this->_dirty[$field]);                                                                             
     811                 :     }                                                                                                                    
     812                 :                                                                                                                          
     813                 :     /**                                                                                                                  
     814                 :      * Enter description here...                                                                                         
     815                 :      *                                                                                                                   
     816                 :      * @param string $field                                                                                              
     817                 :      * @param boolean $flag                                                                                              
     818                 :      * @return Varien_Object                                                                                             
     819                 :      */                                                                                                                  
     820                 :     public function flagDirty($field, $flag=true)                                                                        
     821                 :     {                                                                                                                    
     822               0 :         if (is_null($field)) {                                                                                           
     823               0 :             foreach ($this->getData() as $field=>$value) {                                                               
     824               0 :                 $this->flagDirty($field, $flag);                                                                         
     825               0 :             }                                                                                                            
     826               0 :         } else {                                                                                                         
     827               0 :             if ($flag) {                                                                                                 
     828               0 :                 $this->_dirty[$field] = true;                                                                            
     829               0 :             } else {                                                                                                     
     830               0 :                 unset($this->_dirty[$field]);                                                                            
     831                 :             }                                                                                                            
     832                 :         }                                                                                                                
     833               0 :         return $this;                                                                                                    
     834                 :     }                                                                                                                    
     835                 : }                                                                                                                        

Generated by PHP_CodeCoverage 1.0.4 using PHP 5.3.4 and PHPUnit 3.5.13 at Tue Jul 5 9:07:16 UTC 2011.