home *** CD-ROM | disk | FTP | other *** search
/ HTML Examples / WP.iso / wordpress / wp-includes / SimplePie / Registry.php < prev    next >
Encoding:
PHP Script  |  2012-11-21  |  5.9 KB  |  225 lines
  1. <?php
  2. /**
  3.  * SimplePie
  4.  *
  5.  * A PHP-Based RSS and Atom Feed Framework.
  6.  * Takes the hard work out of managing a complete RSS/Atom solution.
  7.  *
  8.  * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
  9.  * All rights reserved.
  10.  *
  11.  * Redistribution and use in source and binary forms, with or without modification, are
  12.  * permitted provided that the following conditions are met:
  13.  *
  14.  *     * Redistributions of source code must retain the above copyright notice, this list of
  15.  *       conditions and the following disclaimer.
  16.  *
  17.  *     * Redistributions in binary form must reproduce the above copyright notice, this list
  18.  *       of conditions and the following disclaimer in the documentation and/or other materials
  19.  *       provided with the distribution.
  20.  *
  21.  *     * Neither the name of the SimplePie Team nor the names of its contributors may be used
  22.  *       to endorse or promote products derived from this software without specific prior
  23.  *       written permission.
  24.  *
  25.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
  26.  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  27.  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
  28.  * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30.  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  32.  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33.  * POSSIBILITY OF SUCH DAMAGE.
  34.  *
  35.  * @package SimplePie
  36.  * @version 1.3.1
  37.  * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
  38.  * @author Ryan Parman
  39.  * @author Geoffrey Sneddon
  40.  * @author Ryan McCue
  41.  * @link http://simplepie.org/ SimplePie
  42.  * @license http://www.opensource.org/licenses/bsd-license.php BSD License
  43.  */
  44.  
  45. /**
  46.  * Handles creating objects and calling methods
  47.  *
  48.  * Access this via {@see SimplePie::get_registry()}
  49.  *
  50.  * @package SimplePie
  51.  */
  52. class SimplePie_Registry
  53. {
  54.     /**
  55.      * Default class mapping
  56.      *
  57.      * Overriding classes *must* subclass these.
  58.      *
  59.      * @var array
  60.      */
  61.     protected $default = array(
  62.         'Cache' => 'SimplePie_Cache',
  63.         'Locator' => 'SimplePie_Locator',
  64.         'Parser' => 'SimplePie_Parser',
  65.         'File' => 'SimplePie_File',
  66.         'Sanitize' => 'SimplePie_Sanitize',
  67.         'Item' => 'SimplePie_Item',
  68.         'Author' => 'SimplePie_Author',
  69.         'Category' => 'SimplePie_Category',
  70.         'Enclosure' => 'SimplePie_Enclosure',
  71.         'Caption' => 'SimplePie_Caption',
  72.         'Copyright' => 'SimplePie_Copyright',
  73.         'Credit' => 'SimplePie_Credit',
  74.         'Rating' => 'SimplePie_Rating',
  75.         'Restriction' => 'SimplePie_Restriction',
  76.         'Content_Type_Sniffer' => 'SimplePie_Content_Type_Sniffer',
  77.         'Source' => 'SimplePie_Source',
  78.         'Misc' => 'SimplePie_Misc',
  79.         'XML_Declaration_Parser' => 'SimplePie_XML_Declaration_Parser',
  80.         'Parse_Date' => 'SimplePie_Parse_Date',
  81.     );
  82.  
  83.     /**
  84.      * Class mapping
  85.      *
  86.      * @see register()
  87.      * @var array
  88.      */
  89.     protected $classes = array();
  90.  
  91.     /**
  92.      * Legacy classes
  93.      *
  94.      * @see register()
  95.      * @var array
  96.      */
  97.     protected $legacy = array();
  98.  
  99.     /**
  100.      * Constructor
  101.      *
  102.      * No-op
  103.      */
  104.     public function __construct() { }
  105.  
  106.     /**
  107.      * Register a class
  108.      *
  109.      * @param string $type See {@see $default} for names
  110.      * @param string $class Class name, must subclass the corresponding default
  111.      * @param bool $legacy Whether to enable legacy support for this class
  112.      * @return bool Successfulness
  113.      */
  114.     public function register($type, $class, $legacy = false)
  115.     {
  116.         if (!is_subclass_of($class, $this->default[$type]))
  117.         {
  118.             return false;
  119.         }
  120.  
  121.         $this->classes[$type] = $class;
  122.  
  123.         if ($legacy)
  124.         {
  125.             $this->legacy[] = $class;
  126.         }
  127.  
  128.         return true;
  129.     }
  130.  
  131.     /**
  132.      * Get the class registered for a type
  133.      *
  134.      * Where possible, use {@see create()} or {@see call()} instead
  135.      *
  136.      * @param string $type
  137.      * @return string|null
  138.      */
  139.     public function get_class($type)
  140.     {
  141.         if (!empty($this->classes[$type]))
  142.         {
  143.             return $this->classes[$type];
  144.         }
  145.         if (!empty($this->default[$type]))
  146.         {
  147.             return $this->default[$type];
  148.         }
  149.  
  150.         return null;
  151.     }
  152.  
  153.     /**
  154.      * Create a new instance of a given type
  155.      *
  156.      * @param string $type
  157.      * @param array $parameters Parameters to pass to the constructor
  158.      * @return object Instance of class
  159.      */
  160.     public function &create($type, $parameters = array())
  161.     {
  162.         $class = $this->get_class($type);
  163.  
  164.         if (in_array($class, $this->legacy))
  165.         {
  166.             switch ($type)
  167.             {
  168.                 case 'locator':
  169.                     // Legacy: file, timeout, useragent, file_class, max_checked_feeds, content_type_sniffer_class
  170.                     // Specified: file, timeout, useragent, max_checked_feeds
  171.                     $replacement = array($this->get_class('file'), $parameters[3], $this->get_class('content_type_sniffer'));
  172.                     array_splice($parameters, 3, 1, $replacement);
  173.                     break;
  174.             }
  175.         }
  176.  
  177.         if (!method_exists($class, '__construct'))
  178.         {
  179.             $instance = new $class;
  180.         }
  181.         else
  182.         {
  183.             $reflector = new ReflectionClass($class);
  184.             $instance = $reflector->newInstanceArgs($parameters);
  185.         }
  186.  
  187.         if (method_exists($instance, 'set_registry'))
  188.         {
  189.             $instance->set_registry($this);
  190.         }
  191.         return $instance;
  192.     }
  193.  
  194.     /**
  195.      * Call a static method for a type
  196.      *
  197.      * @param string $type
  198.      * @param string $method
  199.      * @param array $parameters
  200.      * @return mixed
  201.      */
  202.     public function &call($type, $method, $parameters = array())
  203.     {
  204.         $class = $this->get_class($type);
  205.  
  206.         if (in_array($class, $this->legacy))
  207.         {
  208.             switch ($type)
  209.             {
  210.                 case 'Cache':
  211.                     // For backwards compatibility with old non-static
  212.                     // Cache::create() methods
  213.                     if ($method === 'get_handler')
  214.                     {
  215.                         $result = @call_user_func_array(array($class, 'create'), $parameters);
  216.                         return $result;
  217.                     }
  218.                     break;
  219.             }
  220.         }
  221.  
  222.         $result = call_user_func_array(array($class, $method), $parameters);
  223.         return $result;
  224.     }
  225. }