Zend Framework - Zend_Mail
Current view: /usr/local/lib/zend/trunk/incubator/library/Zend/Mail/Storage/Abstract.php
Date: Tue Feb 6 18:30:06 CET 2007 Executable lines: 34
Code covered: 79.41% Executed lines: 27
Legend: executed not executed dead code


       1                 : <?php                                                                                              
       2                 : /**                                                                                                
       3                 :  * Zend Framework                                                                                  
       4                 :  *                                                                                                 
       5                 :  * LICENSE                                                                                         
       6                 :  *                                                                                                 
       7                 :  * This source file is subject to version 1.0 of the Zend Framework                                
       8                 :  * license, that is bundled with this package in the file LICENSE, and                             
       9                 :  * is available through the world-wide-web at the following URL:                                   
      10                 :  * http://www.zend.com/license/framework/1_0.txt. If you did not receive                           
      11                 :  * a copy of the Zend Framework license and are unable to obtain it                                
      12                 :  * through the world-wide-web, please send a note to license@zend.com                              
      13                 :  * so we can mail you a copy immediately.                                                          
      14                 :  *                                                                                                 
      15                 :  * @package    Zend_Mail                                                                           
      16                 :  * @copyright  Copyright (c) 2005-2007 Zend Technologies USA Inc. (http://www.zend.com)            
      17                 :  * @license    http://www.zend.com/license/framework/1_0.txt Zend Framework License version 1.0    
      18                 :  */                                                                                                
      19                 :                                                                                                    
      20                 : /**                                                                                                
      21                 :  * Zend_Mail_Exception                                                                             
      22                 :  */                                                                                                
      23                 : require_once 'Zend/Mail/Storage/Exception.php';                                                    
      24                 :                                                                                                    
      25                 : /**                                                                                                
      26                 :  * @package    Zend_Mail                                                                           
      27                 :  * @copyright  Copyright (c) 2005-2007 Zend Technologies USA Inc. (http://www.zend.com)            
      28                 :  * @license    http://www.zend.com/license/framework/1_0.txt Zend Framework License version 1.0    
      29                 :  */                                                                                                
      30                 : abstract class Zend_Mail_Storage_Abstract implements Countable, ArrayAccess, SeekableIterator      
      31                 : {                                                                                                  
      32                 :     /**                                                                                            
      33                 :      * class capabilities with default values                                                      
      34                 :      */                                                                                            
      35                 :     protected $_has = array('uniqueid'  => false,                                                  
      36                 :                             'delete'    => false,                                                  
      37                 :                             'create'    => false,                                                  
      38                 :                             'top'       => false,                                                  
      39                 :                             'fetchPart' => true);                                                  
      40                 :                                                                                                    
      41                 :     /**                                                                                            
      42                 :      * current iteration position                                                                  
      43                 :      */                                                                                            
      44                 :     protected $_iterationPos = 0;                                                                  
      45                 :                                                                                                    
      46                 :     /**                                                                                            
      47                 :      * maximum iteration position (= message count)                                                
      48                 :      */                                                                                            
      49                 :     protected $_iterationMax = null;                                                               
      50                 :                                                                                                    
      51                 :     /**                                                                                            
      52                 :      * Getter for has-properties. The standard has properties                                      
      53                 :      * are: hasFolder, hasUniqueid, hasDelete, hasCreate, hasTop                                   
      54                 :      *                                                                                             
      55                 :      * The valid values for the has-properties are:                                                
      56                 :      *   - true if a feature is supported                                                          
      57                 :      *   - false if a feature is not supported                                                     
      58                 :      *   - null is it's not yet known or it can't be know if a feature is supported                
      59                 :      *                                                                                             
      60                 :      * @param  string $var  property name                                                          
      61                 :      * @return bool         supported or not                                                       
      62                 :      */                                                                                            
      63                 :     public function __get($var)                                                                    
      64                 :     {                                                                                              
      65               7 :         if(strpos($var, 'has') === 0) {                                                            
      66               6 :             $var = strtolower(substr($var, 3));                                                    
      67               6 :             return isset($this->_has[$var]) ? $this->_has[$var] : null;                            
      68                 :         }                                                                                          
      69                 :                                                                                                    
      70               1 :         throw new Zend_Mail_Storage_Exception($var . ' not found');                                
      71                 :     }                                                                                              
      72                 :                                                                                                    
      73                 :                                                                                                    
      74                 :     /**                                                                                            
      75                 :      * Get a full list of features supported by the specific mail lib and the server               
      76                 :      *                                                                                             
      77                 :      * @return array list of features as array(featurename => true|false[|null])                   
      78                 :      */                                                                                            
      79                 :     public function getCapabilities()                                                              
      80                 :     {                                                                                              
      81               0 :         return $this->_has;                                                                        
      82                 :     }                                                                                              
      83                 :                                                                                                    
      84                 :                                                                                                    
      85                 :     /**                                                                                            
      86                 :      * Count messages with a flag or all messages in current box/folder                            
      87                 :      * Flags might not be supported by all mail libs (exceptions is thrown)                        
      88                 :      *                                                                                             
      89                 :      * @param  int $flags  filter by flags                                                         
      90                 :      * @throws Zend_Mail_Storage_Exception                                                         
      91                 :      * @return int number of messages                                                              
      92                 :      */                                                                                            
      93                 :     abstract public function countMessages($flags = null);                                         
      94                 :                                                                                                    
      95                 :                                                                                                    
      96                 :     /**                                                                                            
      97                 :      * Get a list of messages with number and size                                                 
      98                 :      *                                                                                             
      99                 :      * @param  int       $id  number of message                                                    
     100                 :      * @return int|array      size of given message of list with all messages as array(num => size)
     101                 :      */                                                                                            
     102                 :     abstract public function getSize($id = 0);                                                     
     103                 :                                                                                                    
     104                 :                                                                                                    
     105                 :     /**                                                                                            
     106                 :      * Get a message with headers and body                                                         
     107                 :      *                                                                                             
     108                 :      * @param  $id  int number of message                                                          
     109                 :      * @return Zend_Mail_Message                                                                   
     110                 :      */                                                                                            
     111                 :     abstract public function getMessage($id);                                                      
     112                 :                                                                                                    
     113                 :                                                                                                    
     114                 :     abstract public function getRaw($id, $part);                                                   
     115                 :                                                                                                    
     116                 :                                                                                                    
     117                 :     /**                                                                                            
     118                 :      * Create instance with parameters                                                             
     119                 :      *                                                                                             
     120                 :      * @param  array $params  mail reader specific parameters                                      
     121                 :      * @throws Zend_Mail_Storage_Exception                                                         
     122                 :      */                                                                                            
     123                 :     abstract public function __construct($params);                                                 
     124                 :                                                                                                    
     125                 :                                                                                                    
     126                 :     /**                                                                                            
     127                 :      * Destructor calls close() and therefore closes the resource.                                 
     128                 :      */                                                                                            
     129                 :     public function __destruct()                                                                   
     130                 :     {                                                                                              
     131              63 :         $this->close();                                                                            
     132              63 :     }                                                                                              
     133                 :                                                                                                    
     134                 :                                                                                                    
     135                 :     /**                                                                                            
     136                 :      * Close resource for mail lib. If you need to control, when the resource                      
     137                 :      * is closed. Otherwise the destructor would call this.                                        
     138                 :      */                                                                                            
     139                 :     abstract public function close();                                                              
     140                 :                                                                                                    
     141                 :                                                                                                    
     142                 :     /**                                                                                            
     143                 :      * Keep the resource alive.                                                                    
     144                 :      */                                                                                            
     145                 :     abstract public function noop();                                                               
     146                 :                                                                                                    
     147                 :     /**                                                                                            
     148                 :      * delete a message from current box/folder                                                    
     149                 :      */                                                                                            
     150                 :     abstract public function removeMessage($id);                                                   
     151                 :                                                                                                    
     152                 :     // interface implementations follows                                                           
     153                 :                                                                                                    
     154                 :     /**                                                                                            
     155                 :      * Countable::count()                                                                          
     156                 :      * @internal                                                                                   
     157                 :      * @return   int                                                                               
     158                 :      */                                                                                            
     159                 :      public function count()                                                                       
     160                 :      {                                                                                             
     161               1 :         return $this->countMessages();                                                             
     162                 :      }                                                                                             
     163                 :                                                                                                    
     164                 :                                                                                                    
     165                 :      /**                                                                                           
     166                 :       * ArrayAccess::offsetExists()                                                                
     167                 :       * @internal                                                                                  
     168                 :       * @param    int     $id                                                                      
     169                 :       * @return   boolean                                                                          
     170                 :       */                                                                                           
     171                 :      public function offsetExists($id)                                                             
     172                 :      {                                                                                             
     173                 :         try {                                                                                      
     174               2 :             if ($this->getMessage($id)) {                                                          
     175               1 :                 return true;                                                                       
     176                 :             }                                                                                      
     177               1 :         } catch(Zend_Mail_Storage_Exception $e) {}                                                 
     178                 :                                                                                                    
     179               1 :         return false;                                                                              
     180                 :      }                                                                                             
     181                 :                                                                                                    
     182                 :                                                                                                    
     183                 :      /**                                                                                           
     184                 :       * ArrayAccess::offsetGet()                                                                   
     185                 :       * @internal                                                                                  
     186                 :       * @param    int $id                                                                          
     187                 :       * @return   Zend_Mail_Message message object                                                 
     188                 :       */                                                                                           
     189                 :      public function offsetGet($id)                                                                
     190                 :      {                                                                                             
     191               3 :         return $this->getMessage($id);                                                             
     192                 :      }                                                                                             
     193                 :                                                                                                    
     194                 :                                                                                                    
     195                 :      /**                                                                                           
     196                 :       * ArrayAccess::offsetSet()                                                                   
     197                 :       * @internal                                                                                  
     198                 :       * @param    id     $id                                                                       
     199                 :       * @param    mixed  $value                                                                    
     200                 :       * @throws   Zend_Mail_Storage_Exception                                                      
     201                 :       * @return   void                                                                             
     202                 :       */                                                                                           
     203                 :      public function offsetSet($id, $value)                                                        
     204                 :      {                                                                                             
     205               1 :         throw new Zend_Mail_Storage_Exception('cannot write mail messages via array access');      
     206                 :      }                                                                                             
     207                 :                                                                                                    
     208                 :                                                                                                    
     209                 :      /**                                                                                           
     210                 :       * ArrayAccess::offsetUnset()                                                                 
     211                 :       * @internal                                                                                  
     212                 :       * @param    int   $id                                                                        
     213                 :       * @return   boolean success                                                                  
     214                 :       */                                                                                           
     215                 :      public function offsetUnset($id)                                                              
     216                 :      {                                                                                             
     217               0 :         return $this->removeMessage($id);                                                          
     218                 :      }                                                                                             
     219                 :                                                                                                    
     220                 :                                                                                                    
     221                 :      /**                                                                                           
     222                 :       * Iterator::rewind()                                                                         
     223                 :       *                                                                                            
     224                 :       * Rewind always gets the new count from the storage. Thus if you use                         
     225                 :       * the interfaces and your scripts take long you should use reset()                           
     226                 :       * from time to time.                                                                         
     227                 :       *                                                                                            
     228                 :       * @internal                                                                                  
     229                 :       * @return   void                                                                             
     230                 :       */                                                                                           
     231                 :      public function rewind()                                                                      
     232                 :      {                                                                                             
     233               5 :         $this->_iterationMax = $this->countMessages();                                             
     234               5 :         $this->_iterationPos = 1;                                                                  
     235               5 :      }                                                                                             
     236                 :                                                                                                    
     237                 :                                                                                                    
     238                 :      /**                                                                                           
     239                 :       * Iterator::current()                                                                        
     240                 :       * @internal                                                                                  
     241                 :       * @return   Zend_Mail_Message current message                                                
     242                 :       */                                                                                           
     243                 :      public function current()                                                                     
     244                 :      {                                                                                             
     245               5 :         return $this->getMessage($this->_iterationPos);                                            
     246                 :      }                                                                                             
     247                 :                                                                                                    
     248                 :                                                                                                    
     249                 :      /**                                                                                           
     250                 :       * Iterator::key()                                                                            
     251                 :       * @internal                                                                                  
     252                 :       * @return   int id of current position                                                       
     253                 :       */                                                                                           
     254                 :      public function key()                                                                         
     255                 :      {                                                                                             
     256               5 :         return $this->_iterationPos;                                                               
     257                 :      }                                                                                             
     258                 :                                                                                                    
     259                 :                                                                                                    
     260                 :      /**                                                                                           
     261                 :       * Iterator::next()                                                                           
     262                 :       * @internal                                                                                  
     263                 :       * @return   void                                                                             
     264                 :       */                                                                                           
     265                 :      public function next()                                                                        
     266                 :      {                                                                                             
     267               5 :         ++$this->_iterationPos;                                                                    
     268               5 :      }                                                                                             
     269                 :                                                                                                    
     270                 :                                                                                                    
     271                 :      /**                                                                                           
     272                 :       * Iterator::valid()                                                                          
     273                 :       * @internal                                                                                  
     274                 :       * @return   boolean                                                                          
     275                 :       */                                                                                           
     276                 :      public function valid()                                                                       
     277                 :      {                                                                                             
     278               5 :         if($this->_iterationMax === null) {                                                        
     279               0 :           $this->_iterationMax = $this->countMessages();                                           
     280               0 :         }                                                                                          
     281               5 :         return $this->_iterationPos && $this->_iterationPos <= $this->_iterationMax;               
     282                 :      }                                                                                             
     283                 :                                                                                                    
     284                 :                                                                                                    
     285                 :      /**                                                                                           
     286                 :       * SeekableIterator::seek()                                                                   
     287                 :       * @internal                                                                                  
     288                 :       * @param  int $pos                                                                           
     289                 :       * @return void                                                                               
     290                 :       */                                                                                           
     291                 :      public function seek($pos)                                                                    
     292                 :      {                                                                                             
     293               2 :         if($this->_iterationMax === null) {                                                        
     294               0 :           $this->_iterationMax = $this->countMessages();                                           
     295               0 :         }                                                                                          
     296                 :                                                                                                    
     297               2 :         if ($pos > $this->_iterationMax) {                                                         
     298               0 :             throw new OutOfBoundsException('this position does not exist');                        
     299                 :         }                                                                                          
     300               2 :         $this->_iterationPos = $pos;                                                               
     301               2 :      }                                                                                             
     302                 :                                                                                                    
     303                 : }                                                                                                  
     304                 : 

Generated by: PHPUnit 3.0.0 and Xdebug 2.0.0RC2-dev.