/wp-includes/class-simplepie.php

  1. <?php 
  2. if ( ! class_exists( 'SimplePie', false ) ) : 
  3.  
  4. // Load classes we will need. 
  5. require ABSPATH . WPINC . '/SimplePie/Misc.php'; 
  6. require ABSPATH . WPINC . '/SimplePie/Cache.php'; 
  7. require ABSPATH . WPINC . '/SimplePie/File.php'; 
  8. require ABSPATH . WPINC . '/SimplePie/Sanitize.php'; 
  9. require ABSPATH . WPINC . '/SimplePie/Registry.php'; 
  10. require ABSPATH . WPINC . '/SimplePie/IRI.php'; 
  11. require ABSPATH . WPINC . '/SimplePie/Locator.php'; 
  12. require ABSPATH . WPINC . '/SimplePie/Content/Type/Sniffer.php'; 
  13. require ABSPATH . WPINC . '/SimplePie/XML/Declaration/Parser.php'; 
  14. require ABSPATH . WPINC . '/SimplePie/Parser.php'; 
  15. require ABSPATH . WPINC . '/SimplePie/Item.php'; 
  16. require ABSPATH . WPINC . '/SimplePie/Parse/Date.php'; 
  17. require ABSPATH . WPINC . '/SimplePie/Author.php'; 
  18.  
  19. /** 
  20.  * WordPress autoloader for SimplePie. 
  21.  * 
  22.  * @since 3.5.0 
  23.  */ 
  24. function wp_simplepie_autoload( $class ) { 
  25.   if ( 0 !== strpos( $class, 'SimplePie_' ) ) 
  26.       return; 
  27.  
  28.   $file = ABSPATH . WPINC . '/' . str_replace( '_', '/', $class ) . '.php'; 
  29.   include( $file ); 
  30. } 
  31.  
  32. /** 
  33.  * We autoload classes we may not need. 
  34.  */ 
  35. spl_autoload_register( 'wp_simplepie_autoload' ); 
  36.  
  37. /** 
  38.  * SimplePie 
  39.  * 
  40.  * A PHP-Based RSS and Atom Feed Framework. 
  41.  * Takes the hard work out of managing a complete RSS/Atom solution. 
  42.  * 
  43.  * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors 
  44.  * All rights reserved. 
  45.  * 
  46.  * Redistribution and use in source and binary forms, with or without modification, are 
  47.  * permitted provided that the following conditions are met: 
  48.  * 
  49.  *     * Redistributions of source code must retain the above copyright notice, this list of 
  50.  *       conditions and the following disclaimer. 
  51.  * 
  52.  *     * Redistributions in binary form must reproduce the above copyright notice, this list 
  53.  *       of conditions and the following disclaimer in the documentation and/or other materials 
  54.  *       provided with the distribution. 
  55.  * 
  56.  *     * Neither the name of the SimplePie Team nor the names of its contributors may be used 
  57.  *       to endorse or promote products derived from this software without specific prior 
  58.  *       written permission. 
  59.  * 
  60.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS 
  61.  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
  62.  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS 
  63.  * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
  64.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
  65.  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
  66.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
  67.  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
  68.  * POSSIBILITY OF SUCH DAMAGE. 
  69.  * 
  70.  * @package SimplePie 
  71.  * @version 1.3.1 
  72.  * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue 
  73.  * @author Ryan Parman 
  74.  * @author Geoffrey Sneddon 
  75.  * @author Ryan McCue 
  76.  * @link http://simplepie.org/ SimplePie 
  77.  * @license http://www.opensource.org/licenses/bsd-license.php BSD License 
  78.  */ 
  79.  
  80. /** 
  81.  * SimplePie Name 
  82.  */ 
  83. define('SIMPLEPIE_NAME', 'SimplePie'); 
  84.  
  85. /** 
  86.  * SimplePie Version 
  87.  */ 
  88. define('SIMPLEPIE_VERSION', '1.3.1'); 
  89.  
  90. /** 
  91.  * SimplePie Build 
  92.  * @todo Hardcode for release (there's no need to have to call SimplePie_Misc::get_build() only every load of simplepie.inc) 
  93.  */ 
  94. define('SIMPLEPIE_BUILD', gmdate('YmdHis', SimplePie_Misc::get_build())); 
  95.  
  96. /** 
  97.  * SimplePie Website URL 
  98.  */ 
  99. define('SIMPLEPIE_URL', 'http://simplepie.org'); 
  100.  
  101. /** 
  102.  * SimplePie Useragent 
  103.  * @see SimplePie::set_useragent() 
  104.  */ 
  105. define('SIMPLEPIE_USERAGENT', SIMPLEPIE_NAME . '/' . SIMPLEPIE_VERSION . ' (Feed Parser; ' . SIMPLEPIE_URL . '; Allow like Gecko) Build/' . SIMPLEPIE_BUILD); 
  106.  
  107. /** 
  108.  * SimplePie Linkback 
  109.  */ 
  110. define('SIMPLEPIE_LINKBACK', '<a href="' . SIMPLEPIE_URL . '" title="' . SIMPLEPIE_NAME . ' ' . SIMPLEPIE_VERSION . '">' . SIMPLEPIE_NAME . '</a>'); 
  111.  
  112. /** 
  113.  * No Autodiscovery 
  114.  * @see SimplePie::set_autodiscovery_level() 
  115.  */ 
  116. define('SIMPLEPIE_LOCATOR_NONE', 0); 
  117.  
  118. /** 
  119.  * Feed Link Element Autodiscovery 
  120.  * @see SimplePie::set_autodiscovery_level() 
  121.  */ 
  122. define('SIMPLEPIE_LOCATOR_AUTODISCOVERY', 1); 
  123.  
  124. /** 
  125.  * Local Feed Extension Autodiscovery 
  126.  * @see SimplePie::set_autodiscovery_level() 
  127.  */ 
  128. define('SIMPLEPIE_LOCATOR_LOCAL_EXTENSION', 2); 
  129.  
  130. /** 
  131.  * Local Feed Body Autodiscovery 
  132.  * @see SimplePie::set_autodiscovery_level() 
  133.  */ 
  134. define('SIMPLEPIE_LOCATOR_LOCAL_BODY', 4); 
  135.  
  136. /** 
  137.  * Remote Feed Extension Autodiscovery 
  138.  * @see SimplePie::set_autodiscovery_level() 
  139.  */ 
  140. define('SIMPLEPIE_LOCATOR_REMOTE_EXTENSION', 8); 
  141.  
  142. /** 
  143.  * Remote Feed Body Autodiscovery 
  144.  * @see SimplePie::set_autodiscovery_level() 
  145.  */ 
  146. define('SIMPLEPIE_LOCATOR_REMOTE_BODY', 16); 
  147.  
  148. /** 
  149.  * All Feed Autodiscovery 
  150.  * @see SimplePie::set_autodiscovery_level() 
  151.  */ 
  152. define('SIMPLEPIE_LOCATOR_ALL', 31); 
  153.  
  154. /** 
  155.  * No known feed type 
  156.  */ 
  157. define('SIMPLEPIE_TYPE_NONE', 0); 
  158.  
  159. /** 
  160.  * RSS 0.90 
  161.  */ 
  162. define('SIMPLEPIE_TYPE_RSS_090', 1); 
  163.  
  164. /** 
  165.  * RSS 0.91 (Netscape) 
  166.  */ 
  167. define('SIMPLEPIE_TYPE_RSS_091_NETSCAPE', 2); 
  168.  
  169. /** 
  170.  * RSS 0.91 (Userland) 
  171.  */ 
  172. define('SIMPLEPIE_TYPE_RSS_091_USERLAND', 4); 
  173.  
  174. /** 
  175.  * RSS 0.91 (both Netscape and Userland) 
  176.  */ 
  177. define('SIMPLEPIE_TYPE_RSS_091', 6); 
  178.  
  179. /** 
  180.  * RSS 0.92 
  181.  */ 
  182. define('SIMPLEPIE_TYPE_RSS_092', 8); 
  183.  
  184. /** 
  185.  * RSS 0.93 
  186.  */ 
  187. define('SIMPLEPIE_TYPE_RSS_093', 16); 
  188.  
  189. /** 
  190.  * RSS 0.94 
  191.  */ 
  192. define('SIMPLEPIE_TYPE_RSS_094', 32); 
  193.  
  194. /** 
  195.  * RSS 1.0 
  196.  */ 
  197. define('SIMPLEPIE_TYPE_RSS_10', 64); 
  198.  
  199. /** 
  200.  * RSS 2.0 
  201.  */ 
  202. define('SIMPLEPIE_TYPE_RSS_20', 128); 
  203.  
  204. /** 
  205.  * RDF-based RSS 
  206.  */ 
  207. define('SIMPLEPIE_TYPE_RSS_RDF', 65); 
  208.  
  209. /** 
  210.  * Non-RDF-based RSS (truly intended as syndication format) 
  211.  */ 
  212. define('SIMPLEPIE_TYPE_RSS_SYNDICATION', 190); 
  213.  
  214. /** 
  215.  * All RSS 
  216.  */ 
  217. define('SIMPLEPIE_TYPE_RSS_ALL', 255); 
  218.  
  219. /** 
  220.  * Atom 0.3 
  221.  */ 
  222. define('SIMPLEPIE_TYPE_ATOM_03', 256); 
  223.  
  224. /** 
  225.  * Atom 1.0 
  226.  */ 
  227. define('SIMPLEPIE_TYPE_ATOM_10', 512); 
  228.  
  229. /** 
  230.  * All Atom 
  231.  */ 
  232. define('SIMPLEPIE_TYPE_ATOM_ALL', 768); 
  233.  
  234. /** 
  235.  * All feed types 
  236.  */ 
  237. define('SIMPLEPIE_TYPE_ALL', 1023); 
  238.  
  239. /** 
  240.  * No construct 
  241.  */ 
  242. define('SIMPLEPIE_CONSTRUCT_NONE', 0); 
  243.  
  244. /** 
  245.  * Text construct 
  246.  */ 
  247. define('SIMPLEPIE_CONSTRUCT_TEXT', 1); 
  248.  
  249. /** 
  250.  * HTML construct 
  251.  */ 
  252. define('SIMPLEPIE_CONSTRUCT_HTML', 2); 
  253.  
  254. /** 
  255.  * XHTML construct 
  256.  */ 
  257. define('SIMPLEPIE_CONSTRUCT_XHTML', 4); 
  258.  
  259. /** 
  260.  * base64-encoded construct 
  261.  */ 
  262. define('SIMPLEPIE_CONSTRUCT_BASE64', 8); 
  263.  
  264. /** 
  265.  * IRI construct 
  266.  */ 
  267. define('SIMPLEPIE_CONSTRUCT_IRI', 16); 
  268.  
  269. /** 
  270.  * A construct that might be HTML 
  271.  */ 
  272. define('SIMPLEPIE_CONSTRUCT_MAYBE_HTML', 32); 
  273.  
  274. /** 
  275.  * All constructs 
  276.  */ 
  277. define('SIMPLEPIE_CONSTRUCT_ALL', 63); 
  278.  
  279. /** 
  280.  * Don't change case 
  281.  */ 
  282. define('SIMPLEPIE_SAME_CASE', 1); 
  283.  
  284. /** 
  285.  * Change to lowercase 
  286.  */ 
  287. define('SIMPLEPIE_LOWERCASE', 2); 
  288.  
  289. /** 
  290.  * Change to uppercase 
  291.  */ 
  292. define('SIMPLEPIE_UPPERCASE', 4); 
  293.  
  294. /** 
  295.  * PCRE for HTML attributes 
  296.  */ 
  297. define('SIMPLEPIE_PCRE_HTML_ATTRIBUTE', '((?:[\x09\x0A\x0B\x0C\x0D\x20]+[^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x2F\x3D\x3E]*(?:[\x09\x0A\x0B\x0C\x0D\x20]*=[\x09\x0A\x0B\x0C\x0D\x20]*(?:"(?:[^"]*)"|\'(?:[^\']*)\'|(?:[^\x09\x0A\x0B\x0C\x0D\x20\x22\x27\x3E][^\x09\x0A\x0B\x0C\x0D\x20\x3E]*)?))?)*)[\x09\x0A\x0B\x0C\x0D\x20]*'); 
  298.  
  299. /** 
  300.  * PCRE for XML attributes 
  301.  */ 
  302. define('SIMPLEPIE_PCRE_XML_ATTRIBUTE', '((?:\s+(?:(?:[^\s:]+:)?[^\s:]+)\s*=\s*(?:"(?:[^"]*)"|\'(?:[^\']*)\'))*)\s*'); 
  303.  
  304. /** 
  305.  * XML Namespace 
  306.  */ 
  307. define('SIMPLEPIE_NAMESPACE_XML', 'http://www.w3.org/XML/1998/namespace'); 
  308.  
  309. /** 
  310.  * Atom 1.0 Namespace 
  311.  */ 
  312. define('SIMPLEPIE_NAMESPACE_ATOM_10', 'http://www.w3.org/2005/Atom'); 
  313.  
  314. /** 
  315.  * Atom 0.3 Namespace 
  316.  */ 
  317. define('SIMPLEPIE_NAMESPACE_ATOM_03', 'http://purl.org/atom/ns#'); 
  318.  
  319. /** 
  320.  * RDF Namespace 
  321.  */ 
  322. define('SIMPLEPIE_NAMESPACE_RDF', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'); 
  323.  
  324. /** 
  325.  * RSS 0.90 Namespace 
  326.  */ 
  327. define('SIMPLEPIE_NAMESPACE_RSS_090', 'http://my.netscape.com/rdf/simple/0.9/'); 
  328.  
  329. /** 
  330.  * RSS 1.0 Namespace 
  331.  */ 
  332. define('SIMPLEPIE_NAMESPACE_RSS_10', 'http://purl.org/rss/1.0/'); 
  333.  
  334. /** 
  335.  * RSS 1.0 Content Module Namespace 
  336.  */ 
  337. define('SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT', 'http://purl.org/rss/1.0/modules/content/'); 
  338.  
  339. /** 
  340.  * RSS 2.0 Namespace 
  341.  * (Stupid, I know, but I'm certain it will confuse people less with support.) 
  342.  */ 
  343. define('SIMPLEPIE_NAMESPACE_RSS_20', ''); 
  344.  
  345. /** 
  346.  * DC 1.0 Namespace 
  347.  */ 
  348. define('SIMPLEPIE_NAMESPACE_DC_10', 'http://purl.org/dc/elements/1.0/'); 
  349.  
  350. /** 
  351.  * DC 1.1 Namespace 
  352.  */ 
  353. define('SIMPLEPIE_NAMESPACE_DC_11', 'http://purl.org/dc/elements/1.1/'); 
  354.  
  355. /** 
  356.  * W3C Basic Geo (WGS84 lat/long) Vocabulary Namespace 
  357.  */ 
  358. define('SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO', 'http://www.w3.org/2003/01/geo/wgs84_pos#'); 
  359.  
  360. /** 
  361.  * GeoRSS Namespace 
  362.  */ 
  363. define('SIMPLEPIE_NAMESPACE_GEORSS', 'http://www.georss.org/georss'); 
  364.  
  365. /** 
  366.  * Media RSS Namespace 
  367.  */ 
  368. define('SIMPLEPIE_NAMESPACE_MEDIARSS', 'http://search.yahoo.com/mrss/'); 
  369.  
  370. /** 
  371.  * Wrong Media RSS Namespace. Caused by a long-standing typo in the spec. 
  372.  */ 
  373. define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG', 'http://search.yahoo.com/mrss'); 
  374.  
  375. /** 
  376.  * Wrong Media RSS Namespace #2. New namespace introduced in Media RSS 1.5. 
  377.  */ 
  378. define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG2', 'http://video.search.yahoo.com/mrss'); 
  379.  
  380. /** 
  381.  * Wrong Media RSS Namespace #3. A possible typo of the Media RSS 1.5 namespace. 
  382.  */ 
  383. define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG3', 'http://video.search.yahoo.com/mrss/'); 
  384.  
  385. /** 
  386.  * Wrong Media RSS Namespace #4. New spec location after the RSS Advisory Board takes it over, but not a valid namespace. 
  387.  */ 
  388. define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG4', 'http://www.rssboard.org/media-rss'); 
  389.  
  390. /** 
  391.  * Wrong Media RSS Namespace #5. A possible typo of the RSS Advisory Board URL. 
  392.  */ 
  393. define('SIMPLEPIE_NAMESPACE_MEDIARSS_WRONG5', 'http://www.rssboard.org/media-rss/'); 
  394.  
  395. /** 
  396.  * iTunes RSS Namespace 
  397.  */ 
  398. define('SIMPLEPIE_NAMESPACE_ITUNES', 'http://www.itunes.com/dtds/podcast-1.0.dtd'); 
  399.  
  400. /** 
  401.  * XHTML Namespace 
  402.  */ 
  403. define('SIMPLEPIE_NAMESPACE_XHTML', 'http://www.w3.org/1999/xhtml'); 
  404.  
  405. /** 
  406.  * IANA Link Relations Registry 
  407.  */ 
  408. define('SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY', 'http://www.iana.org/assignments/relation/'); 
  409.  
  410. /** 
  411.  * No file source 
  412.  */ 
  413. define('SIMPLEPIE_FILE_SOURCE_NONE', 0); 
  414.  
  415. /** 
  416.  * Remote file source 
  417.  */ 
  418. define('SIMPLEPIE_FILE_SOURCE_REMOTE', 1); 
  419.  
  420. /** 
  421.  * Local file source 
  422.  */ 
  423. define('SIMPLEPIE_FILE_SOURCE_LOCAL', 2); 
  424.  
  425. /** 
  426.  * fsockopen() file source 
  427.  */ 
  428. define('SIMPLEPIE_FILE_SOURCE_FSOCKOPEN', 4); 
  429.  
  430. /** 
  431.  * cURL file source 
  432.  */ 
  433. define('SIMPLEPIE_FILE_SOURCE_CURL', 8); 
  434.  
  435. /** 
  436.  * file_get_contents() file source 
  437.  */ 
  438. define('SIMPLEPIE_FILE_SOURCE_FILE_GET_CONTENTS', 16); 
  439.  
  440.  
  441.  
  442. /** 
  443.  * SimplePie 
  444.  * 
  445.  * @package SimplePie 
  446.  * @subpackage API 
  447.  */ 
  448. class SimplePie 
  449. { 
  450.   /** 
  451.    * @var array Raw data 
  452.    * @access private 
  453.    */ 
  454.   public $data = array(); 
  455.  
  456.   /** 
  457.    * @var mixed Error string 
  458.    * @access private 
  459.    */ 
  460.   public $error; 
  461.  
  462.   /** 
  463.    * @var object Instance of SimplePie_Sanitize (or other class) 
  464.    * @see SimplePie::set_sanitize_class() 
  465.    * @access private 
  466.    */ 
  467.   public $sanitize; 
  468.  
  469.   /** 
  470.    * @var string SimplePie Useragent 
  471.    * @see SimplePie::set_useragent() 
  472.    * @access private 
  473.    */ 
  474.   public $useragent = SIMPLEPIE_USERAGENT; 
  475.  
  476.   /** 
  477.    * @var string Feed URL 
  478.    * @see SimplePie::set_feed_url() 
  479.    * @access private 
  480.    */ 
  481.   public $feed_url; 
  482.  
  483.   /** 
  484.    * @var object Instance of SimplePie_File to use as a feed 
  485.    * @see SimplePie::set_file() 
  486.    * @access private 
  487.    */ 
  488.   public $file; 
  489.  
  490.   /** 
  491.    * @var string Raw feed data 
  492.    * @see SimplePie::set_raw_data() 
  493.    * @access private 
  494.    */ 
  495.   public $raw_data; 
  496.  
  497.   /** 
  498.    * @var int Timeout for fetching remote files 
  499.    * @see SimplePie::set_timeout() 
  500.    * @access private 
  501.    */ 
  502.   public $timeout = 10; 
  503.  
  504.   /** 
  505.    * @var bool Forces fsockopen() to be used for remote files instead 
  506.    * of cURL, even if a new enough version is installed 
  507.    * @see SimplePie::force_fsockopen() 
  508.    * @access private 
  509.    */ 
  510.   public $force_fsockopen = false; 
  511.  
  512.   /** 
  513.    * @var bool Force the given data/URL to be treated as a feed no matter what 
  514.    * it appears like 
  515.    * @see SimplePie::force_feed() 
  516.    * @access private 
  517.    */ 
  518.   public $force_feed = false; 
  519.  
  520.   /** 
  521.    * @var bool Enable/Disable Caching 
  522.    * @see SimplePie::enable_cache() 
  523.    * @access private 
  524.    */ 
  525.   public $cache = true; 
  526.  
  527.   /** 
  528.    * @var int Cache duration (in seconds) 
  529.    * @see SimplePie::set_cache_duration() 
  530.    * @access private 
  531.    */ 
  532.   public $cache_duration = 3600; 
  533.  
  534.   /** 
  535.    * @var int Auto-discovery cache duration (in seconds) 
  536.    * @see SimplePie::set_autodiscovery_cache_duration() 
  537.    * @access private 
  538.    */ 
  539.   public $autodiscovery_cache_duration = 604800; // 7 Days. 
  540.  
  541.   /** 
  542.    * @var string Cache location (relative to executing script) 
  543.    * @see SimplePie::set_cache_location() 
  544.    * @access private 
  545.    */ 
  546.   public $cache_location = './cache'; 
  547.  
  548.   /** 
  549.    * @var string Function that creates the cache filename 
  550.    * @see SimplePie::set_cache_name_function() 
  551.    * @access private 
  552.    */ 
  553.   public $cache_name_function = 'md5'; 
  554.  
  555.   /** 
  556.    * @var bool Reorder feed by date descending 
  557.    * @see SimplePie::enable_order_by_date() 
  558.    * @access private 
  559.    */ 
  560.   public $order_by_date = true; 
  561.  
  562.   /** 
  563.    * @var mixed Force input encoding to be set to the follow value 
  564.    * (false, or anything type-cast to false, disables this feature) 
  565.    * @see SimplePie::set_input_encoding() 
  566.    * @access private 
  567.    */ 
  568.   public $input_encoding = false; 
  569.  
  570.   /** 
  571.    * @var int Feed Autodiscovery Level 
  572.    * @see SimplePie::set_autodiscovery_level() 
  573.    * @access private 
  574.    */ 
  575.   public $autodiscovery = SIMPLEPIE_LOCATOR_ALL; 
  576.  
  577.   /** 
  578.    * Class registry object 
  579.    * 
  580.    * @var SimplePie_Registry 
  581.    */ 
  582.   public $registry; 
  583.  
  584.   /** 
  585.    * @var int Maximum number of feeds to check with autodiscovery 
  586.    * @see SimplePie::set_max_checked_feeds() 
  587.    * @access private 
  588.    */ 
  589.   public $max_checked_feeds = 10; 
  590.  
  591.   /** 
  592.    * @var array All the feeds found during the autodiscovery process 
  593.    * @see SimplePie::get_all_discovered_feeds() 
  594.    * @access private 
  595.    */ 
  596.   public $all_discovered_feeds = array(); 
  597.  
  598.   /** 
  599.    * @var string Web-accessible path to the handler_image.php file. 
  600.    * @see SimplePie::set_image_handler() 
  601.    * @access private 
  602.    */ 
  603.   public $image_handler = ''; 
  604.  
  605.   /** 
  606.    * @var array Stores the URLs when multiple feeds are being initialized. 
  607.    * @see SimplePie::set_feed_url() 
  608.    * @access private 
  609.    */ 
  610.   public $multifeed_url = array(); 
  611.  
  612.   /** 
  613.    * @var array Stores SimplePie objects when multiple feeds initialized. 
  614.    * @access private 
  615.    */ 
  616.   public $multifeed_objects = array(); 
  617.  
  618.   /** 
  619.    * @var array Stores the get_object_vars() array for use with multifeeds. 
  620.    * @see SimplePie::set_feed_url() 
  621.    * @access private 
  622.    */ 
  623.   public $config_settings = null; 
  624.  
  625.   /** 
  626.    * @var integer Stores the number of items to return per-feed with multifeeds. 
  627.    * @see SimplePie::set_item_limit() 
  628.    * @access private 
  629.    */ 
  630.   public $item_limit = 0; 
  631.  
  632.   /** 
  633.    * @var array Stores the default attributes to be stripped by strip_attributes(). 
  634.    * @see SimplePie::strip_attributes() 
  635.    * @access private 
  636.    */ 
  637.   public $strip_attributes = array('bgsound', 'class', 'expr', 'id', 'style', 'onclick', 'onerror', 'onfinish', 'onmouseover', 'onmouseout', 'onfocus', 'onblur', 'lowsrc', 'dynsrc'); 
  638.  
  639.   /** 
  640.    * @var array Stores the default tags to be stripped by strip_htmltags(). 
  641.    * @see SimplePie::strip_htmltags() 
  642.    * @access private 
  643.    */ 
  644.   public $strip_htmltags = array('base', 'blink', 'body', 'doctype', 'embed', 'font', 'form', 'frame', 'frameset', 'html', 'iframe', 'input', 'marquee', 'meta', 'noscript', 'object', 'param', 'script', 'style'); 
  645.  
  646.   /** 
  647.    * The SimplePie class contains feed level data and options 
  648.    * 
  649.    * To use SimplePie, create the SimplePie object with no parameters. You can 
  650.    * then set configuration options using the provided methods. After setting 
  651.    * them, you must initialise the feed using $feed->init(). At that point the 
  652.    * object's methods and properties will be available to you. 
  653.    * 
  654.    * Previously, it was possible to pass in the feed URL along with cache 
  655.    * options directly into the constructor. This has been removed as of 1.3 as 
  656.    * it caused a lot of confusion. 
  657.    * 
  658.    * @since 1.0 Preview Release 
  659.    */ 
  660.   public function __construct() 
  661.   { 
  662.       if (version_compare(PHP_VERSION, '5.2', '<')) 
  663.       { 
  664.           trigger_error('PHP 4.x, 5.0 and 5.1 are no longer supported. Please upgrade to PHP 5.2 or newer.'); 
  665.           die(); 
  666.       } 
  667.  
  668.       // Other objects, instances created here so we can set options on them 
  669.       $this->sanitize = new SimplePie_Sanitize(); 
  670.       $this->registry = new SimplePie_Registry(); 
  671.  
  672.       if (func_num_args() > 0) 
  673.       { 
  674.           $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 
  675.           trigger_error('Passing parameters to the constructor is no longer supported. Please use set_feed_url(), set_cache_location(), and set_cache_location() directly.', $level); 
  676.  
  677.           $args = func_get_args(); 
  678.           switch (count($args)) { 
  679.               case 3: 
  680.                   $this->set_cache_duration($args[2]); 
  681.               case 2: 
  682.                   $this->set_cache_location($args[1]); 
  683.               case 1: 
  684.                   $this->set_feed_url($args[0]); 
  685.                   $this->init(); 
  686.           } 
  687.       } 
  688.   } 
  689.  
  690.   /** 
  691.    * Used for converting object to a string 
  692.    */ 
  693.   public function __toString() 
  694.   { 
  695.       return md5(serialize($this->data)); 
  696.   } 
  697.  
  698.   /** 
  699.    * Remove items that link back to this before destroying this object 
  700.    */ 
  701.   public function __destruct() 
  702.   { 
  703.       if ((version_compare(PHP_VERSION, '5.3', '<') || !gc_enabled()) && !ini_get('zend.ze1_compatibility_mode')) 
  704.       { 
  705.           if (!empty($this->data['items'])) 
  706.           { 
  707.               foreach ($this->data['items'] as $item) 
  708.               { 
  709.                   $item->__destruct(); 
  710.               } 
  711.               unset($item, $this->data['items']); 
  712.           } 
  713.           if (!empty($this->data['ordered_items'])) 
  714.           { 
  715.               foreach ($this->data['ordered_items'] as $item) 
  716.               { 
  717.                   $item->__destruct(); 
  718.               } 
  719.               unset($item, $this->data['ordered_items']); 
  720.           } 
  721.       } 
  722.   } 
  723.  
  724.   /** 
  725.    * Force the given data/URL to be treated as a feed 
  726.    * 
  727.    * This tells SimplePie to ignore the content-type provided by the server. 
  728.    * Be careful when using this option, as it will also disable autodiscovery. 
  729.    * 
  730.    * @since 1.1 
  731.    * @param bool $enable Force the given data/URL to be treated as a feed 
  732.    */ 
  733.   public function force_feed($enable = false) 
  734.   { 
  735.       $this->force_feed = (bool) $enable; 
  736.   } 
  737.  
  738.   /** 
  739.    * Set the URL of the feed you want to parse 
  740.    * 
  741.    * This allows you to enter the URL of the feed you want to parse, or the 
  742.    * website you want to try to use auto-discovery on. This takes priority 
  743.    * over any set raw data. 
  744.    * 
  745.    * You can set multiple feeds to mash together by passing an array instead 
  746.    * of a string for the $url. Remember that with each additional feed comes 
  747.    * additional processing and resources. 
  748.    * 
  749.    * @since 1.0 Preview Release 
  750.    * @see set_raw_data() 
  751.    * @param string|array $url This is the URL (or array of URLs) that you want to parse. 
  752.    */ 
  753.   public function set_feed_url($url) 
  754.   { 
  755.       $this->multifeed_url = array(); 
  756.       if (is_array($url)) 
  757.       { 
  758.           foreach ($url as $value) 
  759.           { 
  760.               $this->multifeed_url[] = $this->registry->call('Misc', 'fix_protocol', array($value, 1)); 
  761.           } 
  762.       } 
  763.       else 
  764.       { 
  765.           $this->feed_url = $this->registry->call('Misc', 'fix_protocol', array($url, 1)); 
  766.       } 
  767.   } 
  768.  
  769.   /** 
  770.    * Set an instance of {@see SimplePie_File} to use as a feed 
  771.    * 
  772.    * @param SimplePie_File &$file 
  773.    * @return bool True on success, false on failure 
  774.    */ 
  775.   public function set_file(&$file) 
  776.   { 
  777.       if ($file instanceof SimplePie_File) 
  778.       { 
  779.           $this->feed_url = $file->url; 
  780.           $this->file =& $file; 
  781.           return true; 
  782.       } 
  783.       return false; 
  784.   } 
  785.  
  786.   /** 
  787.    * Set the raw XML data to parse 
  788.    * 
  789.    * Allows you to use a string of RSS/Atom data instead of a remote feed. 
  790.    * 
  791.    * If you have a feed available as a string in PHP, you can tell SimplePie 
  792.    * to parse that data string instead of a remote feed. Any set feed URL 
  793.    * takes precedence. 
  794.    * 
  795.    * @since 1.0 Beta 3 
  796.    * @param string $data RSS or Atom data as a string. 
  797.    * @see set_feed_url() 
  798.    */ 
  799.   public function set_raw_data($data) 
  800.   { 
  801.       $this->raw_data = $data; 
  802.   } 
  803.  
  804.   /** 
  805.    * Set the the default timeout for fetching remote feeds 
  806.    * 
  807.    * This allows you to change the maximum time the feed's server to respond 
  808.    * and send the feed back. 
  809.    * 
  810.    * @since 1.0 Beta 3 
  811.    * @param int $timeout The maximum number of seconds to spend waiting to retrieve a feed. 
  812.    */ 
  813.   public function set_timeout($timeout = 10) 
  814.   { 
  815.       $this->timeout = (int) $timeout; 
  816.   } 
  817.  
  818.   /** 
  819.    * Force SimplePie to use fsockopen() instead of cURL 
  820.    * 
  821.    * @since 1.0 Beta 3 
  822.    * @param bool $enable Force fsockopen() to be used 
  823.    */ 
  824.   public function force_fsockopen($enable = false) 
  825.   { 
  826.       $this->force_fsockopen = (bool) $enable; 
  827.   } 
  828.  
  829.   /** 
  830.    * Enable/disable caching in SimplePie. 
  831.    * 
  832.    * This option allows you to disable caching all-together in SimplePie. 
  833.    * However, disabling the cache can lead to longer load times. 
  834.    * 
  835.    * @since 1.0 Preview Release 
  836.    * @param bool $enable Enable caching 
  837.    */ 
  838.   public function enable_cache($enable = true) 
  839.   { 
  840.       $this->cache = (bool) $enable; 
  841.   } 
  842.  
  843.   /** 
  844.    * Set the length of time (in seconds) that the contents of a feed will be 
  845.    * cached 
  846.    * 
  847.    * @param int $seconds The feed content cache duration 
  848.    */ 
  849.   public function set_cache_duration($seconds = 3600) 
  850.   { 
  851.       $this->cache_duration = (int) $seconds; 
  852.   } 
  853.  
  854.   /** 
  855.    * Set the length of time (in seconds) that the autodiscovered feed URL will 
  856.    * be cached 
  857.    * 
  858.    * @param int $seconds The autodiscovered feed URL cache duration. 
  859.    */ 
  860.   public function set_autodiscovery_cache_duration($seconds = 604800) 
  861.   { 
  862.       $this->autodiscovery_cache_duration = (int) $seconds; 
  863.   } 
  864.  
  865.   /** 
  866.    * Set the file system location where the cached files should be stored 
  867.    * 
  868.    * @param string $location The file system location. 
  869.    */ 
  870.   public function set_cache_location($location = './cache') 
  871.   { 
  872.       $this->cache_location = (string) $location; 
  873.   } 
  874.  
  875.   /** 
  876.    * Set whether feed items should be sorted into reverse chronological order 
  877.    * 
  878.    * @param bool $enable Sort as reverse chronological order. 
  879.    */ 
  880.   public function enable_order_by_date($enable = true) 
  881.   { 
  882.       $this->order_by_date = (bool) $enable; 
  883.   } 
  884.  
  885.   /** 
  886.    * Set the character encoding used to parse the feed 
  887.    * 
  888.    * This overrides the encoding reported by the feed, however it will fall 
  889.    * back to the normal encoding detection if the override fails 
  890.    * 
  891.    * @param string $encoding Character encoding 
  892.    */ 
  893.   public function set_input_encoding($encoding = false) 
  894.   { 
  895.       if ($encoding) 
  896.       { 
  897.           $this->input_encoding = (string) $encoding; 
  898.       } 
  899.       else 
  900.       { 
  901.           $this->input_encoding = false; 
  902.       } 
  903.   } 
  904.  
  905.   /** 
  906.    * Set how much feed autodiscovery to do 
  907.    * 
  908.    * @see SIMPLEPIE_LOCATOR_NONE 
  909.    * @see SIMPLEPIE_LOCATOR_AUTODISCOVERY 
  910.    * @see SIMPLEPIE_LOCATOR_LOCAL_EXTENSION 
  911.    * @see SIMPLEPIE_LOCATOR_LOCAL_BODY 
  912.    * @see SIMPLEPIE_LOCATOR_REMOTE_EXTENSION 
  913.    * @see SIMPLEPIE_LOCATOR_REMOTE_BODY 
  914.    * @see SIMPLEPIE_LOCATOR_ALL 
  915.    * @param int $level Feed Autodiscovery Level (level can be a combination of the above constants, see bitwise OR operator) 
  916.    */ 
  917.   public function set_autodiscovery_level($level = SIMPLEPIE_LOCATOR_ALL) 
  918.   { 
  919.       $this->autodiscovery = (int) $level; 
  920.   } 
  921.  
  922.   /** 
  923.    * Get the class registry 
  924.    * 
  925.    * Use this to override SimplePie's default classes 
  926.    * @see SimplePie_Registry 
  927.    * @return SimplePie_Registry 
  928.    */ 
  929.   public function &get_registry() 
  930.   { 
  931.       return $this->registry; 
  932.   } 
  933.  
  934.   /**#@+ 
  935.    * Useful when you are overloading or extending SimplePie's default classes. 
  936.    * 
  937.    * @deprecated Use {@see get_registry()} instead 
  938.    * @link http://php.net/manual/en/language.oop5.basic.php#language.oop5.basic.extends PHP5 extends documentation 
  939.    * @param string $class Name of custom class 
  940.    * @return boolean True on success, false otherwise 
  941.    */ 
  942.   /** 
  943.    * Set which class SimplePie uses for caching 
  944.    */ 
  945.   public function set_cache_class($class = 'SimplePie_Cache') 
  946.   { 
  947.       return $this->registry->register('Cache', $class, true); 
  948.   } 
  949.  
  950.   /** 
  951.    * Set which class SimplePie uses for auto-discovery 
  952.    */ 
  953.   public function set_locator_class($class = 'SimplePie_Locator') 
  954.   { 
  955.       return $this->registry->register('Locator', $class, true); 
  956.   } 
  957.  
  958.   /** 
  959.    * Set which class SimplePie uses for XML parsing 
  960.    */ 
  961.   public function set_parser_class($class = 'SimplePie_Parser') 
  962.   { 
  963.       return $this->registry->register('Parser', $class, true); 
  964.   } 
  965.  
  966.   /** 
  967.    * Set which class SimplePie uses for remote file fetching 
  968.    */ 
  969.   public function set_file_class($class = 'SimplePie_File') 
  970.   { 
  971.       return $this->registry->register('File', $class, true); 
  972.   } 
  973.  
  974.   /** 
  975.    * Set which class SimplePie uses for data sanitization 
  976.    */ 
  977.   public function set_sanitize_class($class = 'SimplePie_Sanitize') 
  978.   { 
  979.       return $this->registry->register('Sanitize', $class, true); 
  980.   } 
  981.  
  982.   /** 
  983.    * Set which class SimplePie uses for handling feed items 
  984.    */ 
  985.   public function set_item_class($class = 'SimplePie_Item') 
  986.   { 
  987.       return $this->registry->register('Item', $class, true); 
  988.   } 
  989.  
  990.   /** 
  991.    * Set which class SimplePie uses for handling author data 
  992.    */ 
  993.   public function set_author_class($class = 'SimplePie_Author') 
  994.   { 
  995.       return $this->registry->register('Author', $class, true); 
  996.   } 
  997.  
  998.   /** 
  999.    * Set which class SimplePie uses for handling category data 
  1000.    */ 
  1001.   public function set_category_class($class = 'SimplePie_Category') 
  1002.   { 
  1003.       return $this->registry->register('Category', $class, true); 
  1004.   } 
  1005.  
  1006.   /** 
  1007.    * Set which class SimplePie uses for feed enclosures 
  1008.    */ 
  1009.   public function set_enclosure_class($class = 'SimplePie_Enclosure') 
  1010.   { 
  1011.       return $this->registry->register('Enclosure', $class, true); 
  1012.   } 
  1013.  
  1014.   /** 
  1015.    * Set which class SimplePie uses for `<media:text>` captions 
  1016.    */ 
  1017.   public function set_caption_class($class = 'SimplePie_Caption') 
  1018.   { 
  1019.       return $this->registry->register('Caption', $class, true); 
  1020.   } 
  1021.  
  1022.   /** 
  1023.    * Set which class SimplePie uses for `<media:copyright>` 
  1024.    */ 
  1025.   public function set_copyright_class($class = 'SimplePie_Copyright') 
  1026.   { 
  1027.       return $this->registry->register('Copyright', $class, true); 
  1028.   } 
  1029.  
  1030.   /** 
  1031.    * Set which class SimplePie uses for `<media:credit>` 
  1032.    */ 
  1033.   public function set_credit_class($class = 'SimplePie_Credit') 
  1034.   { 
  1035.       return $this->registry->register('Credit', $class, true); 
  1036.   } 
  1037.  
  1038.   /** 
  1039.    * Set which class SimplePie uses for `<media:rating>` 
  1040.    */ 
  1041.   public function set_rating_class($class = 'SimplePie_Rating') 
  1042.   { 
  1043.       return $this->registry->register('Rating', $class, true); 
  1044.   } 
  1045.  
  1046.   /** 
  1047.    * Set which class SimplePie uses for `<media:restriction>` 
  1048.    */ 
  1049.   public function set_restriction_class($class = 'SimplePie_Restriction') 
  1050.   { 
  1051.       return $this->registry->register('Restriction', $class, true); 
  1052.   } 
  1053.  
  1054.   /** 
  1055.    * Set which class SimplePie uses for content-type sniffing 
  1056.    */ 
  1057.   public function set_content_type_sniffer_class($class = 'SimplePie_Content_Type_Sniffer') 
  1058.   { 
  1059.       return $this->registry->register('Content_Type_Sniffer', $class, true); 
  1060.   } 
  1061.  
  1062.   /** 
  1063.    * Set which class SimplePie uses item sources 
  1064.    */ 
  1065.   public function set_source_class($class = 'SimplePie_Source') 
  1066.   { 
  1067.       return $this->registry->register('Source', $class, true); 
  1068.   } 
  1069.   /**#@-*/ 
  1070.  
  1071.   /** 
  1072.    * Set the user agent string 
  1073.    * 
  1074.    * @param string $ua New user agent string. 
  1075.    */ 
  1076.   public function set_useragent($ua = SIMPLEPIE_USERAGENT) 
  1077.   { 
  1078.       $this->useragent = (string) $ua; 
  1079.   } 
  1080.  
  1081.   /** 
  1082.    * Set callback function to create cache filename with 
  1083.    * 
  1084.    * @param mixed $function Callback function 
  1085.    */ 
  1086.   public function set_cache_name_function($function = 'md5') 
  1087.   { 
  1088.       if (is_callable($function)) 
  1089.       { 
  1090.           $this->cache_name_function = $function; 
  1091.       } 
  1092.   } 
  1093.  
  1094.   /** 
  1095.    * Set options to make SP as fast as possible 
  1096.    * 
  1097.    * Forgoes a substantial amount of data sanitization in favor of speed. This 
  1098.    * turns SimplePie into a dumb parser of feeds. 
  1099.    * 
  1100.    * @param bool $set Whether to set them or not 
  1101.    */ 
  1102.   public function set_stupidly_fast($set = false) 
  1103.   { 
  1104.       if ($set) 
  1105.       { 
  1106.           $this->enable_order_by_date(false); 
  1107.           $this->remove_div(false); 
  1108.           $this->strip_comments(false); 
  1109.           $this->strip_htmltags(false); 
  1110.           $this->strip_attributes(false); 
  1111.           $this->set_image_handler(false); 
  1112.       } 
  1113.   } 
  1114.  
  1115.   /** 
  1116.    * Set maximum number of feeds to check with autodiscovery 
  1117.    * 
  1118.    * @param int $max Maximum number of feeds to check 
  1119.    */ 
  1120.   public function set_max_checked_feeds($max = 10) 
  1121.   { 
  1122.       $this->max_checked_feeds = (int) $max; 
  1123.   } 
  1124.  
  1125.   public function remove_div($enable = true) 
  1126.   { 
  1127.       $this->sanitize->remove_div($enable); 
  1128.   } 
  1129.  
  1130.   public function strip_htmltags($tags = '', $encode = null) 
  1131.   { 
  1132.       if ($tags === '') 
  1133.       { 
  1134.           $tags = $this->strip_htmltags; 
  1135.       } 
  1136.       $this->sanitize->strip_htmltags($tags); 
  1137.       if ($encode !== null) 
  1138.       { 
  1139.           $this->sanitize->encode_instead_of_strip($tags); 
  1140.       } 
  1141.   } 
  1142.  
  1143.   public function encode_instead_of_strip($enable = true) 
  1144.   { 
  1145.       $this->sanitize->encode_instead_of_strip($enable); 
  1146.   } 
  1147.  
  1148.   public function strip_attributes($attribs = '') 
  1149.   { 
  1150.       if ($attribs === '') 
  1151.       { 
  1152.           $attribs = $this->strip_attributes; 
  1153.       } 
  1154.       $this->sanitize->strip_attributes($attribs); 
  1155.   } 
  1156.  
  1157.   /** 
  1158.    * Set the output encoding 
  1159.    * 
  1160.    * Allows you to override SimplePie's output to match that of your webpage. 
  1161.    * This is useful for times when your webpages are not being served as 
  1162.    * UTF-8.  This setting will be obeyed by {@see handle_content_type()}, and 
  1163.    * is similar to {@see set_input_encoding()}. 
  1164.    * 
  1165.    * It should be noted, however, that not all character encodings can support 
  1166.    * all characters.  If your page is being served as ISO-8859-1 and you try 
  1167.    * to display a Japanese feed, you'll likely see garbled characters. 
  1168.    * Because of this, it is highly recommended to ensure that your webpages 
  1169.    * are served as UTF-8. 
  1170.    * 
  1171.    * The number of supported character encodings depends on whether your web 
  1172.    * host supports {@link http://php.net/mbstring mbstring},  
  1173.    * {@link http://php.net/iconv iconv}, or both. See 
  1174.    * {@link http://simplepie.org/wiki/faq/Supported_Character_Encodings} for 
  1175.    * more information. 
  1176.    * 
  1177.    * @param string $encoding 
  1178.    */ 
  1179.   public function set_output_encoding($encoding = 'UTF-8') 
  1180.   { 
  1181.       $this->sanitize->set_output_encoding($encoding); 
  1182.   } 
  1183.  
  1184.   public function strip_comments($strip = false) 
  1185.   { 
  1186.       $this->sanitize->strip_comments($strip); 
  1187.   } 
  1188.  
  1189.   /** 
  1190.    * Set element/attribute key/value pairs of HTML attributes 
  1191.    * containing URLs that need to be resolved relative to the feed 
  1192.    * 
  1193.    * Defaults to |a|@href, |area|@href, |blockquote|@cite, |del|@cite,  
  1194.    * |form|@action, |img|@longdesc, |img|@src, |input|@src, |ins|@cite,  
  1195.    * |q|@cite 
  1196.    * 
  1197.    * @since 1.0 
  1198.    * @param array|null $element_attribute Element/attribute key/value pairs, null for default 
  1199.    */ 
  1200.   public function set_url_replacements($element_attribute = null) 
  1201.   { 
  1202.       $this->sanitize->set_url_replacements($element_attribute); 
  1203.   } 
  1204.  
  1205.   /** 
  1206.    * Set the handler to enable the display of cached images. 
  1207.    * 
  1208.    * @param str $page Web-accessible path to the handler_image.php file. 
  1209.    * @param str $qs The query string that the value should be passed to. 
  1210.    */ 
  1211.   public function set_image_handler($page = false, $qs = 'i') 
  1212.   { 
  1213.       if ($page !== false) 
  1214.       { 
  1215.           $this->sanitize->set_image_handler($page . '?' . $qs . '='); 
  1216.       } 
  1217.       else 
  1218.       { 
  1219.           $this->image_handler = ''; 
  1220.       } 
  1221.   } 
  1222.  
  1223.   /** 
  1224.    * Set the limit for items returned per-feed with multifeeds 
  1225.    * 
  1226.    * @param integer $limit The maximum number of items to return. 
  1227.    */ 
  1228.   public function set_item_limit($limit = 0) 
  1229.   { 
  1230.       $this->item_limit = (int) $limit; 
  1231.   } 
  1232.  
  1233.   /** 
  1234.    * Initialize the feed object 
  1235.    * 
  1236.    * This is what makes everything happen.  Period.  This is where all of the 
  1237.    * configuration options get processed, feeds are fetched, cached, and 
  1238.    * parsed, and all of that other good stuff. 
  1239.    * 
  1240.    * @return boolean True if successful, false otherwise 
  1241.    */ 
  1242.   public function init() 
  1243.   { 
  1244.       // Check absolute bare minimum requirements. 
  1245.       if (!extension_loaded('xml') || !extension_loaded('pcre')) 
  1246.       { 
  1247.           return false; 
  1248.       } 
  1249.       // Then check the xml extension is sane (i.e., libxml 2.7.x issue on PHP < 5.2.9 and libxml 2.7.0 to 2.7.2 on any version) if we don't have xmlreader. 
  1250.       elseif (!extension_loaded('xmlreader')) 
  1251.       { 
  1252.           static $xml_is_sane = null; 
  1253.           if ($xml_is_sane === null) 
  1254.           { 
  1255.               $parser_check = xml_parser_create(); 
  1256.               xml_parse_into_struct($parser_check, '<foo>&</foo>', $values); 
  1257.               xml_parser_free($parser_check); 
  1258.               $xml_is_sane = isset($values[0]['value']); 
  1259.           } 
  1260.           if (!$xml_is_sane) 
  1261.           { 
  1262.               return false; 
  1263.           } 
  1264.       } 
  1265.  
  1266.       if (method_exists($this->sanitize, 'set_registry')) 
  1267.       { 
  1268.           $this->sanitize->set_registry($this->registry); 
  1269.       } 
  1270.  
  1271.       // Pass whatever was set with config options over to the sanitizer. 
  1272.       // Pass the classes in for legacy support; new classes should use the registry instead 
  1273.       $this->sanitize->pass_cache_data($this->cache, $this->cache_location, $this->cache_name_function, $this->registry->get_class('Cache')); 
  1274.       $this->sanitize->pass_file_data($this->registry->get_class('File'), $this->timeout, $this->useragent, $this->force_fsockopen); 
  1275.  
  1276.       if (!empty($this->multifeed_url)) 
  1277.       { 
  1278.           $i = 0; 
  1279.           $success = 0; 
  1280.           $this->multifeed_objects = array(); 
  1281.           $this->error = array(); 
  1282.           foreach ($this->multifeed_url as $url) 
  1283.           { 
  1284.               $this->multifeed_objects[$i] = clone $this; 
  1285.               $this->multifeed_objects[$i]->set_feed_url($url); 
  1286.               $single_success = $this->multifeed_objects[$i]->init(); 
  1287.               $success |= $single_success; 
  1288.               if (!$single_success) 
  1289.               { 
  1290.                   $this->error[$i] = $this->multifeed_objects[$i]->error(); 
  1291.               } 
  1292.               $i++; 
  1293.           } 
  1294.           return (bool) $success; 
  1295.       } 
  1296.       elseif ($this->feed_url === null && $this->raw_data === null) 
  1297.       { 
  1298.           return false; 
  1299.       } 
  1300.  
  1301.       $this->error = null; 
  1302.       $this->data = array(); 
  1303.       $this->multifeed_objects = array(); 
  1304.       $cache = false; 
  1305.  
  1306.       if ($this->feed_url !== null) 
  1307.       { 
  1308.           $parsed_feed_url = $this->registry->call('Misc', 'parse_url', array($this->feed_url)); 
  1309.  
  1310.           // Decide whether to enable caching 
  1311.           if ($this->cache && $parsed_feed_url['scheme'] !== '') 
  1312.           { 
  1313.               $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, call_user_func($this->cache_name_function, $this->feed_url), 'spc')); 
  1314.           } 
  1315.  
  1316.           // Fetch the data via SimplePie_File into $this->raw_data 
  1317.           if (($fetched = $this->fetch_data($cache)) === true) 
  1318.           { 
  1319.               return true; 
  1320.           } 
  1321.           elseif ($fetched === false) { 
  1322.               return false; 
  1323.           } 
  1324.  
  1325.           list($headers, $sniffed) = $fetched; 
  1326.       } 
  1327.  
  1328.       // Set up array of possible encodings 
  1329.       $encodings = array(); 
  1330.  
  1331.       // First check to see if input has been overridden. 
  1332.       if ($this->input_encoding !== false) 
  1333.       { 
  1334.           $encodings[] = $this->input_encoding; 
  1335.       } 
  1336.  
  1337.       $application_types = array('application/xml', 'application/xml-dtd', 'application/xml-external-parsed-entity'); 
  1338.       $text_types = array('text/xml', 'text/xml-external-parsed-entity'); 
  1339.  
  1340.       // RFC 3023 (only applies to sniffed content) 
  1341.       if (isset($sniffed)) 
  1342.       { 
  1343.           if (in_array($sniffed, $application_types) || substr($sniffed, 0, 12) === 'application/' && substr($sniffed, -4) === '+xml') 
  1344.           { 
  1345.               if (isset($headers['content-type']) && preg_match('/;\x20?charset=([^;]*)/i', $headers['content-type'], $charset)) 
  1346.               { 
  1347.                   $encodings[] = strtoupper($charset[1]); 
  1348.               } 
  1349.               $encodings = array_merge($encodings, $this->registry->call('Misc', 'xml_encoding', array($this->raw_data, &$this->registry))); 
  1350.               $encodings[] = 'UTF-8'; 
  1351.           } 
  1352.           elseif (in_array($sniffed, $text_types) || substr($sniffed, 0, 5) === 'text/' && substr($sniffed, -4) === '+xml') 
  1353.           { 
  1354.               if (isset($headers['content-type']) && preg_match('/;\x20?charset=([^;]*)/i', $headers['content-type'], $charset)) 
  1355.               { 
  1356.                   $encodings[] = $charset[1]; 
  1357.               } 
  1358.               $encodings[] = 'US-ASCII'; 
  1359.           } 
  1360.           // Text MIME-type default 
  1361.           elseif (substr($sniffed, 0, 5) === 'text/') 
  1362.           { 
  1363.               $encodings[] = 'US-ASCII'; 
  1364.           } 
  1365.       } 
  1366.  
  1367.       // Fallback to XML 1.0 Appendix F.1/UTF-8/ISO-8859-1 
  1368.       $encodings = array_merge($encodings, $this->registry->call('Misc', 'xml_encoding', array($this->raw_data, &$this->registry))); 
  1369.       $encodings[] = 'UTF-8'; 
  1370.       $encodings[] = 'ISO-8859-1'; 
  1371.  
  1372.       // There's no point in trying an encoding twice 
  1373.       $encodings = array_unique($encodings); 
  1374.  
  1375.       // Loop through each possible encoding, till we return something, or run out of possibilities 
  1376.       foreach ($encodings as $encoding) 
  1377.       { 
  1378.           // Change the encoding to UTF-8 (as we always use UTF-8 internally) 
  1379.           if ($utf8_data = $this->registry->call('Misc', 'change_encoding', array($this->raw_data, $encoding, 'UTF-8'))) 
  1380.           { 
  1381.               // Create new parser 
  1382.               $parser = $this->registry->create('Parser'); 
  1383.  
  1384.               // If it's parsed fine 
  1385.               if ($parser->parse($utf8_data, 'UTF-8')) 
  1386.               { 
  1387.                   $this->data = $parser->get_data(); 
  1388.                   if (!($this->get_type() & ~SIMPLEPIE_TYPE_NONE)) 
  1389.                   { 
  1390.                       $this->error = "A feed could not be found at $this->feed_url. This does not appear to be a valid RSS or Atom feed."; 
  1391.                       $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); 
  1392.                       return false; 
  1393.                   } 
  1394.  
  1395.                   if (isset($headers)) 
  1396.                   { 
  1397.                       $this->data['headers'] = $headers; 
  1398.                   } 
  1399.                   $this->data['build'] = SIMPLEPIE_BUILD; 
  1400.  
  1401.                   // Cache the file if caching is enabled 
  1402.                   if ($cache && !$cache->save($this)) 
  1403.                   { 
  1404.                       trigger_error("$this->cache_location is not writeable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING); 
  1405.                   } 
  1406.                   return true; 
  1407.               } 
  1408.           } 
  1409.       } 
  1410.  
  1411.       if (isset($parser)) 
  1412.       { 
  1413.           // We have an error, just set SimplePie_Misc::error to it and quit 
  1414.           $this->error = sprintf('This XML document is invalid, likely due to invalid characters. XML error: %s at line %d, column %d', $parser->get_error_string(), $parser->get_current_line(), $parser->get_current_column()); 
  1415.       } 
  1416.       else 
  1417.       { 
  1418.           $this->error = 'The data could not be converted to UTF-8. You MUST have either the iconv or mbstring extension installed. Upgrading to PHP 5.x (which includes iconv) is highly recommended.'; 
  1419.       } 
  1420.  
  1421.       $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); 
  1422.  
  1423.       return false; 
  1424.   } 
  1425.  
  1426.   /** 
  1427.    * Fetch the data via SimplePie_File 
  1428.    * 
  1429.    * If the data is already cached, attempt to fetch it from there instead 
  1430.    * @param SimplePie_Cache|false $cache Cache handler, or false to not load from the cache 
  1431.    * @return array|true Returns true if the data was loaded from the cache, or an array of HTTP headers and sniffed type 
  1432.    */ 
  1433.   protected function fetch_data(&$cache) 
  1434.   { 
  1435.       // If it's enabled, use the cache 
  1436.       if ($cache) 
  1437.       { 
  1438.           // Load the Cache 
  1439.           $this->data = $cache->load(); 
  1440.           if (!empty($this->data)) 
  1441.           { 
  1442.               // If the cache is for an outdated build of SimplePie 
  1443.               if (!isset($this->data['build']) || $this->data['build'] !== SIMPLEPIE_BUILD) 
  1444.               { 
  1445.                   $cache->unlink(); 
  1446.                   $this->data = array(); 
  1447.               } 
  1448.               // If we've hit a collision just rerun it with caching disabled 
  1449.               elseif (isset($this->data['url']) && $this->data['url'] !== $this->feed_url) 
  1450.               { 
  1451.                   $cache = false; 
  1452.                   $this->data = array(); 
  1453.               } 
  1454.               // If we've got a non feed_url stored (if the page isn't actually a feed, or is a redirect) use that URL. 
  1455.               elseif (isset($this->data['feed_url'])) 
  1456.               { 
  1457.                   // If the autodiscovery cache is still valid use it. 
  1458.                   if ($cache->mtime() + $this->autodiscovery_cache_duration > time()) 
  1459.                   { 
  1460.                       // Do not need to do feed autodiscovery yet. 
  1461.                       if ($this->data['feed_url'] !== $this->data['url']) 
  1462.                       { 
  1463.                           $this->set_feed_url($this->data['feed_url']); 
  1464.                           return $this->init(); 
  1465.                       } 
  1466.  
  1467.                       $cache->unlink(); 
  1468.                       $this->data = array(); 
  1469.                   } 
  1470.               } 
  1471.               // Check if the cache has been updated 
  1472.               elseif ($cache->mtime() + $this->cache_duration < time()) 
  1473.               { 
  1474.                   // If we have last-modified and/or etag set 
  1475.                   if (isset($this->data['headers']['last-modified']) || isset($this->data['headers']['etag'])) 
  1476.                   { 
  1477.                       $headers = array( 
  1478.                           'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1',  
  1479.  ); 
  1480.                       if (isset($this->data['headers']['last-modified'])) 
  1481.                       { 
  1482.                           $headers['if-modified-since'] = $this->data['headers']['last-modified']; 
  1483.                       } 
  1484.                       if (isset($this->data['headers']['etag'])) 
  1485.                       { 
  1486.                           $headers['if-none-match'] = $this->data['headers']['etag']; 
  1487.                       } 
  1488.   
  1489.                       $file = $this->registry->create('File', array($this->feed_url, $this->timeout/10, 5, $headers, $this->useragent, $this->force_fsockopen)); 
  1490.   
  1491.                       if ($file->success) 
  1492.                       { 
  1493.                           if ($file->status_code === 304) 
  1494.                           { 
  1495.                               $cache->touch(); 
  1496.                               return true; 
  1497.                           } 
  1498.                       } 
  1499.                       else 
  1500.                       { 
  1501.                           unset($file); 
  1502.                       } 
  1503.                   } 
  1504.               } 
  1505.               // If the cache is still valid, just return true 
  1506.               else 
  1507.               { 
  1508.                   $this->raw_data = false; 
  1509.                   return true; 
  1510.               } 
  1511.           } 
  1512.           // If the cache is empty, delete it 
  1513.           else 
  1514.           { 
  1515.               $cache->unlink(); 
  1516.               $this->data = array(); 
  1517.           } 
  1518.       } 
  1519.       // If we don't already have the file (it'll only exist if we've opened it to check if the cache has been modified), open it. 
  1520.       if (!isset($file)) 
  1521.       { 
  1522.           if ($this->file instanceof SimplePie_File && $this->file->url === $this->feed_url) 
  1523.           { 
  1524.               $file =& $this->file; 
  1525.           } 
  1526.           else 
  1527.           { 
  1528.               $headers = array( 
  1529.                   'Accept' => 'application/atom+xml, application/rss+xml, application/rdf+xml;q=0.9, application/xml;q=0.8, text/xml;q=0.8, text/html;q=0.7, unknown/unknown;q=0.1, application/unknown;q=0.1, */*;q=0.1',  
  1530.  ); 
  1531.               $file = $this->registry->create('File', array($this->feed_url, $this->timeout, 5, $headers, $this->useragent, $this->force_fsockopen)); 
  1532.           } 
  1533.       } 
  1534.       // If the file connection has an error, set SimplePie::error to that and quit 
  1535.       if (!$file->success && !($file->method & SIMPLEPIE_FILE_SOURCE_REMOTE === 0 || ($file->status_code === 200 || $file->status_code > 206 && $file->status_code < 300))) 
  1536.       { 
  1537.           $this->error = $file->error; 
  1538.           return !empty($this->data); 
  1539.       } 
  1540.  
  1541.       if (!$this->force_feed) 
  1542.       { 
  1543.           // Check if the supplied URL is a feed, if it isn't, look for it. 
  1544.           $locate = $this->registry->create('Locator', array(&$file, $this->timeout, $this->useragent, $this->max_checked_feeds)); 
  1545.  
  1546.           if (!$locate->is_feed($file)) 
  1547.           { 
  1548.               // We need to unset this so that if SimplePie::set_file() has been called that object is untouched 
  1549.               unset($file); 
  1550.               try 
  1551.               { 
  1552.                   if (!($file = $locate->find($this->autodiscovery, $this->all_discovered_feeds))) 
  1553.                   { 
  1554.                       $this->error = "A feed could not be found at $this->feed_url. A feed with an invalid mime type may fall victim to this error, or " . SIMPLEPIE_NAME . " was unable to auto-discover it.. Use force_feed() if you are certain this URL is a real feed."; 
  1555.                       $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, __FILE__, __LINE__)); 
  1556.                       return false; 
  1557.                   } 
  1558.               } 
  1559.               catch (SimplePie_Exception $e) 
  1560.               { 
  1561.                   // This is usually because DOMDocument doesn't exist 
  1562.                   $this->error = $e->getMessage(); 
  1563.                   $this->registry->call('Misc', 'error', array($this->error, E_USER_NOTICE, $e->getFile(), $e->getLine())); 
  1564.                   return false; 
  1565.               } 
  1566.               if ($cache) 
  1567.               { 
  1568.                   $this->data = array('url' => $this->feed_url, 'feed_url' => $file->url, 'build' => SIMPLEPIE_BUILD); 
  1569.                   if (!$cache->save($this)) 
  1570.                   { 
  1571.                       trigger_error("$this->cache_location is not writeable. Make sure you've set the correct relative or absolute path, and that the location is server-writable.", E_USER_WARNING); 
  1572.                   } 
  1573.                   $cache = $this->registry->call('Cache', 'get_handler', array($this->cache_location, call_user_func($this->cache_name_function, $file->url), 'spc')); 
  1574.               } 
  1575.               $this->feed_url = $file->url; 
  1576.           } 
  1577.           $locate = null; 
  1578.       } 
  1579.  
  1580.       $this->raw_data = $file->body; 
  1581.  
  1582.       $headers = $file->headers; 
  1583.       $sniffer = $this->registry->create('Content_Type_Sniffer', array(&$file)); 
  1584.       $sniffed = $sniffer->get_type(); 
  1585.  
  1586.       return array($headers, $sniffed); 
  1587.   } 
  1588.  
  1589.   /** 
  1590.    * Get the error message for the occurred error. 
  1591.    * 
  1592.    * @return string|array Error message, or array of messages for multifeeds 
  1593.    */ 
  1594.   public function error() 
  1595.   { 
  1596.       return $this->error; 
  1597.   } 
  1598.  
  1599.   /** 
  1600.    * Get the raw XML 
  1601.    * 
  1602.    * This is the same as the old `$feed->enable_xml_dump(true)`, but returns 
  1603.    * the data instead of printing it. 
  1604.    * 
  1605.    * @return string|boolean Raw XML data, false if the cache is used 
  1606.    */ 
  1607.   public function get_raw_data() 
  1608.   { 
  1609.       return $this->raw_data; 
  1610.   } 
  1611.  
  1612.   /** 
  1613.    * Get the character encoding used for output 
  1614.    * 
  1615.    * @since Preview Release 
  1616.    * @return string 
  1617.    */ 
  1618.   public function get_encoding() 
  1619.   { 
  1620.       return $this->sanitize->output_encoding; 
  1621.   } 
  1622.  
  1623.   /** 
  1624.    * Send the content-type header with correct encoding 
  1625.    * 
  1626.    * This method ensures that the SimplePie-enabled page is being served with 
  1627.    * the correct {@link http://www.iana.org/assignments/media-types/ mime-type} 
  1628.    * and character encoding HTTP headers (character encoding determined by the 
  1629.    * {@see set_output_encoding} config option). 
  1630.    * 
  1631.    * This won't work properly if any content or whitespace has already been 
  1632.    * sent to the browser, because it relies on PHP's 
  1633.    * {@link http://php.net/header header()} function, and these are the 
  1634.    * circumstances under which the function works. 
  1635.    * 
  1636.    * Because it's setting these settings for the entire page (as is the nature 
  1637.    * of HTTP headers), this should only be used once per page (again, at the 
  1638.    * top). 
  1639.    * 
  1640.    * @param string $mime MIME type to serve the page as 
  1641.    */ 
  1642.   public function handle_content_type($mime = 'text/html') 
  1643.   { 
  1644.       if (!headers_sent()) 
  1645.       { 
  1646.           $header = "Content-type: $mime;"; 
  1647.           if ($this->get_encoding()) 
  1648.           { 
  1649.               $header .= ' charset=' . $this->get_encoding(); 
  1650.           } 
  1651.           else 
  1652.           { 
  1653.               $header .= ' charset=UTF-8'; 
  1654.           } 
  1655.           header($header); 
  1656.       } 
  1657.   } 
  1658.  
  1659.   /** 
  1660.    * Get the type of the feed 
  1661.    * 
  1662.    * This returns a SIMPLEPIE_TYPE_* constant, which can be tested against 
  1663.    * using {@link http://php.net/language.operators.bitwise bitwise operators} 
  1664.    * 
  1665.    * @since 0.8 (usage changed to using constants in 1.0) 
  1666.    * @see SIMPLEPIE_TYPE_NONE Unknown. 
  1667.    * @see SIMPLEPIE_TYPE_RSS_090 RSS 0.90. 
  1668.    * @see SIMPLEPIE_TYPE_RSS_091_NETSCAPE RSS 0.91 (Netscape). 
  1669.    * @see SIMPLEPIE_TYPE_RSS_091_USERLAND RSS 0.91 (Userland). 
  1670.    * @see SIMPLEPIE_TYPE_RSS_091 RSS 0.91. 
  1671.    * @see SIMPLEPIE_TYPE_RSS_092 RSS 0.92. 
  1672.    * @see SIMPLEPIE_TYPE_RSS_093 RSS 0.93. 
  1673.    * @see SIMPLEPIE_TYPE_RSS_094 RSS 0.94. 
  1674.    * @see SIMPLEPIE_TYPE_RSS_10 RSS 1.0. 
  1675.    * @see SIMPLEPIE_TYPE_RSS_20 RSS 2.0.x. 
  1676.    * @see SIMPLEPIE_TYPE_RSS_RDF RDF-based RSS. 
  1677.    * @see SIMPLEPIE_TYPE_RSS_SYNDICATION Non-RDF-based RSS (truly intended as syndication format). 
  1678.    * @see SIMPLEPIE_TYPE_RSS_ALL Any version of RSS. 
  1679.    * @see SIMPLEPIE_TYPE_ATOM_03 Atom 0.3. 
  1680.    * @see SIMPLEPIE_TYPE_ATOM_10 Atom 1.0. 
  1681.    * @see SIMPLEPIE_TYPE_ATOM_ALL Any version of Atom. 
  1682.    * @see SIMPLEPIE_TYPE_ALL Any known/supported feed type. 
  1683.    * @return int SIMPLEPIE_TYPE_* constant 
  1684.    */ 
  1685.   public function get_type() 
  1686.   { 
  1687.       if (!isset($this->data['type'])) 
  1688.       { 
  1689.           $this->data['type'] = SIMPLEPIE_TYPE_ALL; 
  1690.           if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'])) 
  1691.           { 
  1692.               $this->data['type'] &= SIMPLEPIE_TYPE_ATOM_10; 
  1693.           } 
  1694.           elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'])) 
  1695.           { 
  1696.               $this->data['type'] &= SIMPLEPIE_TYPE_ATOM_03; 
  1697.           } 
  1698.           elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'])) 
  1699.           { 
  1700.               if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['channel']) 
  1701.               || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['image']) 
  1702.               || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['item']) 
  1703.               || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_10]['textinput'])) 
  1704.               { 
  1705.                   $this->data['type'] &= SIMPLEPIE_TYPE_RSS_10; 
  1706.               } 
  1707.               if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['channel']) 
  1708.               || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['image']) 
  1709.               || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['item']) 
  1710.               || isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_090]['textinput'])) 
  1711.               { 
  1712.                   $this->data['type'] &= SIMPLEPIE_TYPE_RSS_090; 
  1713.               } 
  1714.           } 
  1715.           elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'])) 
  1716.           { 
  1717.               $this->data['type'] &= SIMPLEPIE_TYPE_RSS_ALL; 
  1718.               if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['attribs']['']['version'])) 
  1719.               { 
  1720.                   switch (trim($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['attribs']['']['version'])) 
  1721.                   { 
  1722.                       case '0.91': 
  1723.                           $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091; 
  1724.                           if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['skiphours']['hour'][0]['data'])) 
  1725.                           { 
  1726.                               switch (trim($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][SIMPLEPIE_NAMESPACE_RSS_20]['skiphours']['hour'][0]['data'])) 
  1727.                               { 
  1728.                                   case '0': 
  1729.                                       $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091_NETSCAPE; 
  1730.                                       break; 
  1731.  
  1732.                                   case '24': 
  1733.                                       $this->data['type'] &= SIMPLEPIE_TYPE_RSS_091_USERLAND; 
  1734.                                       break; 
  1735.                               } 
  1736.                           } 
  1737.                           break; 
  1738.  
  1739.                       case '0.92': 
  1740.                           $this->data['type'] &= SIMPLEPIE_TYPE_RSS_092; 
  1741.                           break; 
  1742.  
  1743.                       case '0.93': 
  1744.                           $this->data['type'] &= SIMPLEPIE_TYPE_RSS_093; 
  1745.                           break; 
  1746.  
  1747.                       case '0.94': 
  1748.                           $this->data['type'] &= SIMPLEPIE_TYPE_RSS_094; 
  1749.                           break; 
  1750.  
  1751.                       case '2.0': 
  1752.                           $this->data['type'] &= SIMPLEPIE_TYPE_RSS_20; 
  1753.                           break; 
  1754.                   } 
  1755.               } 
  1756.           } 
  1757.           else 
  1758.           { 
  1759.               $this->data['type'] = SIMPLEPIE_TYPE_NONE; 
  1760.           } 
  1761.       } 
  1762.       return $this->data['type']; 
  1763.   } 
  1764.  
  1765.   /** 
  1766.    * Get the URL for the feed 
  1767.    * 
  1768.    * May or may not be different from the URL passed to {@see set_feed_url()},  
  1769.    * depending on whether auto-discovery was used. 
  1770.    * 
  1771.    * @since Preview Release (previously called `get_feed_url()` since SimplePie 0.8.) 
  1772.    * @todo If we have a perm redirect we should return the new URL 
  1773.    * @todo When we make the above change, let's support <itunes:new-feed-url> as well 
  1774.    * @todo Also, |atom:link|@rel=self 
  1775.    * @return string|null 
  1776.    */ 
  1777.   public function subscribe_url() 
  1778.   { 
  1779.       if ($this->feed_url !== null) 
  1780.       { 
  1781.           return $this->sanitize($this->feed_url, SIMPLEPIE_CONSTRUCT_IRI); 
  1782.       } 
  1783.       else 
  1784.       { 
  1785.           return null; 
  1786.       } 
  1787.   } 
  1788.  
  1789.   /** 
  1790.    * Get data for an feed-level element 
  1791.    * 
  1792.    * This method allows you to get access to ANY element/attribute that is a 
  1793.    * sub-element of the opening feed tag. 
  1794.    * 
  1795.    * The return value is an indexed array of elements matching the given 
  1796.    * namespace and tag name. Each element has `attribs`, `data` and `child` 
  1797.    * subkeys. For `attribs` and `child`, these contain namespace subkeys. 
  1798.    * `attribs` then has one level of associative name => value data (where 
  1799.    * `value` is a string) after the namespace. `child` has tag-indexed keys 
  1800.    * after the namespace, each member of which is an indexed array matching 
  1801.    * this same format. 
  1802.    * 
  1803.    * For example: 
  1804.    * <pre> 
  1805.    * // This is probably a bad example because we already support 
  1806.    * // <media:content> natively, but it shows you how to parse through 
  1807.    * // the nodes. 
  1808.    * $group = $item->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'group'); 
  1809.    * $content = $group[0]['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']; 
  1810.    * $file = $content[0]['attribs']['']['url']; 
  1811.    * echo $file; 
  1812.    * </pre> 
  1813.    * 
  1814.    * @since 1.0 
  1815.    * @see http://simplepie.org/wiki/faq/supported_xml_namespaces 
  1816.    * @param string $namespace The URL of the XML namespace of the elements you're trying to access 
  1817.    * @param string $tag Tag name 
  1818.    * @return array 
  1819.    */ 
  1820.   public function get_feed_tags($namespace, $tag) 
  1821.   { 
  1822.       $type = $this->get_type(); 
  1823.       if ($type & SIMPLEPIE_TYPE_ATOM_10) 
  1824.       { 
  1825.           if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['child'][$namespace][$tag])) 
  1826.           { 
  1827.               return $this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['child'][$namespace][$tag]; 
  1828.           } 
  1829.       } 
  1830.       if ($type & SIMPLEPIE_TYPE_ATOM_03) 
  1831.       { 
  1832.           if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['child'][$namespace][$tag])) 
  1833.           { 
  1834.               return $this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['child'][$namespace][$tag]; 
  1835.           } 
  1836.       } 
  1837.       if ($type & SIMPLEPIE_TYPE_RSS_RDF) 
  1838.       { 
  1839.           if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][$namespace][$tag])) 
  1840.           { 
  1841.               return $this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['child'][$namespace][$tag]; 
  1842.           } 
  1843.       } 
  1844.       if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) 
  1845.       { 
  1846.           if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][$namespace][$tag])) 
  1847.           { 
  1848.               return $this->data['child'][SIMPLEPIE_NAMESPACE_RSS_20]['rss'][0]['child'][$namespace][$tag]; 
  1849.           } 
  1850.       } 
  1851.       return null; 
  1852.   } 
  1853.  
  1854.   /** 
  1855.    * Get data for an channel-level element 
  1856.    * 
  1857.    * This method allows you to get access to ANY element/attribute in the 
  1858.    * channel/header section of the feed. 
  1859.    * 
  1860.    * See {@see SimplePie::get_feed_tags()} for a description of the return value 
  1861.    * 
  1862.    * @since 1.0 
  1863.    * @see http://simplepie.org/wiki/faq/supported_xml_namespaces 
  1864.    * @param string $namespace The URL of the XML namespace of the elements you're trying to access 
  1865.    * @param string $tag Tag name 
  1866.    * @return array 
  1867.    */ 
  1868.   public function get_channel_tags($namespace, $tag) 
  1869.   { 
  1870.       $type = $this->get_type(); 
  1871.       if ($type & SIMPLEPIE_TYPE_ATOM_ALL) 
  1872.       { 
  1873.           if ($return = $this->get_feed_tags($namespace, $tag)) 
  1874.           { 
  1875.               return $return; 
  1876.           } 
  1877.       } 
  1878.       if ($type & SIMPLEPIE_TYPE_RSS_10) 
  1879.       { 
  1880.           if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'channel')) 
  1881.           { 
  1882.               if (isset($channel[0]['child'][$namespace][$tag])) 
  1883.               { 
  1884.                   return $channel[0]['child'][$namespace][$tag]; 
  1885.               } 
  1886.           } 
  1887.       } 
  1888.       if ($type & SIMPLEPIE_TYPE_RSS_090) 
  1889.       { 
  1890.           if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'channel')) 
  1891.           { 
  1892.               if (isset($channel[0]['child'][$namespace][$tag])) 
  1893.               { 
  1894.                   return $channel[0]['child'][$namespace][$tag]; 
  1895.               } 
  1896.           } 
  1897.       } 
  1898.       if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) 
  1899.       { 
  1900.           if ($channel = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'channel')) 
  1901.           { 
  1902.               if (isset($channel[0]['child'][$namespace][$tag])) 
  1903.               { 
  1904.                   return $channel[0]['child'][$namespace][$tag]; 
  1905.               } 
  1906.           } 
  1907.       } 
  1908.       return null; 
  1909.   } 
  1910.  
  1911.   /** 
  1912.    * Get data for an channel-level element 
  1913.    * 
  1914.    * This method allows you to get access to ANY element/attribute in the 
  1915.    * image/logo section of the feed. 
  1916.    * 
  1917.    * See {@see SimplePie::get_feed_tags()} for a description of the return value 
  1918.    * 
  1919.    * @since 1.0 
  1920.    * @see http://simplepie.org/wiki/faq/supported_xml_namespaces 
  1921.    * @param string $namespace The URL of the XML namespace of the elements you're trying to access 
  1922.    * @param string $tag Tag name 
  1923.    * @return array 
  1924.    */ 
  1925.   public function get_image_tags($namespace, $tag) 
  1926.   { 
  1927.       $type = $this->get_type(); 
  1928.       if ($type & SIMPLEPIE_TYPE_RSS_10) 
  1929.       { 
  1930.           if ($image = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'image')) 
  1931.           { 
  1932.               if (isset($image[0]['child'][$namespace][$tag])) 
  1933.               { 
  1934.                   return $image[0]['child'][$namespace][$tag]; 
  1935.               } 
  1936.           } 
  1937.       } 
  1938.       if ($type & SIMPLEPIE_TYPE_RSS_090) 
  1939.       { 
  1940.           if ($image = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'image')) 
  1941.           { 
  1942.               if (isset($image[0]['child'][$namespace][$tag])) 
  1943.               { 
  1944.                   return $image[0]['child'][$namespace][$tag]; 
  1945.               } 
  1946.           } 
  1947.       } 
  1948.       if ($type & SIMPLEPIE_TYPE_RSS_SYNDICATION) 
  1949.       { 
  1950.           if ($image = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'image')) 
  1951.           { 
  1952.               if (isset($image[0]['child'][$namespace][$tag])) 
  1953.               { 
  1954.                   return $image[0]['child'][$namespace][$tag]; 
  1955.               } 
  1956.           } 
  1957.       } 
  1958.       return null; 
  1959.   } 
  1960.  
  1961.   /** 
  1962.    * Get the base URL value from the feed 
  1963.    * 
  1964.    * Uses `<xml:base>` if available, otherwise uses the first link in the 
  1965.    * feed, or failing that, the URL of the feed itself. 
  1966.    * 
  1967.    * @see get_link 
  1968.    * @see subscribe_url 
  1969.    * 
  1970.    * @param array $element 
  1971.    * @return string 
  1972.    */ 
  1973.   public function get_base($element = array()) 
  1974.   { 
  1975.       if (!($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION) && !empty($element['xml_base_explicit']) && isset($element['xml_base'])) 
  1976.       { 
  1977.           return $element['xml_base']; 
  1978.       } 
  1979.       elseif ($this->get_link() !== null) 
  1980.       { 
  1981.           return $this->get_link(); 
  1982.       } 
  1983.       else 
  1984.       { 
  1985.           return $this->subscribe_url(); 
  1986.       } 
  1987.   } 
  1988.  
  1989.   /** 
  1990.    * Sanitize feed data 
  1991.    * 
  1992.    * @access private 
  1993.    * @see SimplePie_Sanitize::sanitize() 
  1994.    * @param string $data Data to sanitize 
  1995.    * @param int $type One of the SIMPLEPIE_CONSTRUCT_* constants 
  1996.    * @param string $base Base URL to resolve URLs against 
  1997.    * @return string Sanitized data 
  1998.    */ 
  1999.   public function sanitize($data, $type, $base = '') 
  2000.   { 
  2001.       return $this->sanitize->sanitize($data, $type, $base); 
  2002.   } 
  2003.  
  2004.   /** 
  2005.    * Get the title of the feed 
  2006.    * 
  2007.    * Uses `<atom:title>`, `<title>` or `<dc:title>` 
  2008.    * 
  2009.    * @since 1.0 (previously called `get_feed_title` since 0.8) 
  2010.    * @return string|null 
  2011.    */ 
  2012.   public function get_title() 
  2013.   { 
  2014.       if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title')) 
  2015.       { 
  2016.           return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 
  2017.       } 
  2018.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title')) 
  2019.       { 
  2020.           return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 
  2021.       } 
  2022.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title')) 
  2023.       { 
  2024.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 
  2025.       } 
  2026.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title')) 
  2027.       { 
  2028.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 
  2029.       } 
  2030.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title')) 
  2031.       { 
  2032.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 
  2033.       } 
  2034.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title')) 
  2035.       { 
  2036.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2037.       } 
  2038.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title')) 
  2039.       { 
  2040.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2041.       } 
  2042.       else 
  2043.       { 
  2044.           return null; 
  2045.       } 
  2046.   } 
  2047.  
  2048.   /** 
  2049.    * Get a category for the feed 
  2050.    * 
  2051.    * @since Unknown 
  2052.    * @param int $key The category that you want to return.  Remember that arrays begin with 0, not 1 
  2053.    * @return SimplePie_Category|null 
  2054.    */ 
  2055.   public function get_category($key = 0) 
  2056.   { 
  2057.       $categories = $this->get_categories(); 
  2058.       if (isset($categories[$key])) 
  2059.       { 
  2060.           return $categories[$key]; 
  2061.       } 
  2062.       else 
  2063.       { 
  2064.           return null; 
  2065.       } 
  2066.   } 
  2067.  
  2068.   /** 
  2069.    * Get all categories for the feed 
  2070.    * 
  2071.    * Uses `<atom:category>`, `<category>` or `<dc:subject>` 
  2072.    * 
  2073.    * @since Unknown 
  2074.    * @return array|null List of {@see SimplePie_Category} objects 
  2075.    */ 
  2076.   public function get_categories() 
  2077.   { 
  2078.       $categories = array(); 
  2079.  
  2080.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category) 
  2081.       { 
  2082.           $term = null; 
  2083.           $scheme = null; 
  2084.           $label = null; 
  2085.           if (isset($category['attribs']['']['term'])) 
  2086.           { 
  2087.               $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2088.           } 
  2089.           if (isset($category['attribs']['']['scheme'])) 
  2090.           { 
  2091.               $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2092.           } 
  2093.           if (isset($category['attribs']['']['label'])) 
  2094.           { 
  2095.               $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2096.           } 
  2097.           $categories[] = $this->registry->create('Category', array($term, $scheme, $label)); 
  2098.       } 
  2099.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category) 
  2100.       { 
  2101.           // This is really the label, but keep this as the term also for BC. 
  2102.           // Label will also work on retrieving because that falls back to term. 
  2103.           $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2104.           if (isset($category['attribs']['']['domain'])) 
  2105.           { 
  2106.               $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2107.           } 
  2108.           else 
  2109.           { 
  2110.               $scheme = null; 
  2111.           } 
  2112.           $categories[] = $this->registry->create('Category', array($term, $scheme, null)); 
  2113.       } 
  2114.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category) 
  2115.       { 
  2116.           $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 
  2117.       } 
  2118.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category) 
  2119.       { 
  2120.           $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 
  2121.       } 
  2122.  
  2123.       if (!empty($categories)) 
  2124.       { 
  2125.           return array_unique($categories); 
  2126.       } 
  2127.       else 
  2128.       { 
  2129.           return null; 
  2130.       } 
  2131.   } 
  2132.  
  2133.   /** 
  2134.    * Get an author for the feed 
  2135.    * 
  2136.    * @since 1.1 
  2137.    * @param int $key The author that you want to return.  Remember that arrays begin with 0, not 1 
  2138.    * @return SimplePie_Author|null 
  2139.    */ 
  2140.   public function get_author($key = 0) 
  2141.   { 
  2142.       $authors = $this->get_authors(); 
  2143.       if (isset($authors[$key])) 
  2144.       { 
  2145.           return $authors[$key]; 
  2146.       } 
  2147.       else 
  2148.       { 
  2149.           return null; 
  2150.       } 
  2151.   } 
  2152.  
  2153.   /** 
  2154.    * Get all authors for the feed 
  2155.    * 
  2156.    * Uses `<atom:author>`, `<author>`, `<dc:creator>` or `<itunes:author>` 
  2157.    * 
  2158.    * @since 1.1 
  2159.    * @return array|null List of {@see SimplePie_Author} objects 
  2160.    */ 
  2161.   public function get_authors() 
  2162.   { 
  2163.       $authors = array(); 
  2164.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author) 
  2165.       { 
  2166.           $name = null; 
  2167.           $uri = null; 
  2168.           $email = null; 
  2169.           if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'])) 
  2170.           { 
  2171.               $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2172.           } 
  2173.           if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'])) 
  2174.           { 
  2175.               $uri = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0])); 
  2176.           } 
  2177.           if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'])) 
  2178.           { 
  2179.               $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2180.           } 
  2181.           if ($name !== null || $email !== null || $uri !== null) 
  2182.           { 
  2183.               $authors[] = $this->registry->create('Author', array($name, $uri, $email)); 
  2184.           } 
  2185.       } 
  2186.       if ($author = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author')) 
  2187.       { 
  2188.           $name = null; 
  2189.           $url = null; 
  2190.           $email = null; 
  2191.           if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'])) 
  2192.           { 
  2193.               $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2194.           } 
  2195.           if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'])) 
  2196.           { 
  2197.               $url = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0])); 
  2198.           } 
  2199.           if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'])) 
  2200.           { 
  2201.               $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2202.           } 
  2203.           if ($name !== null || $email !== null || $url !== null) 
  2204.           { 
  2205.               $authors[] = $this->registry->create('Author', array($name, $url, $email)); 
  2206.           } 
  2207.       } 
  2208.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author) 
  2209.       { 
  2210.           $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 
  2211.       } 
  2212.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author) 
  2213.       { 
  2214.           $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 
  2215.       } 
  2216.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author) 
  2217.       { 
  2218.           $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null)); 
  2219.       } 
  2220.  
  2221.       if (!empty($authors)) 
  2222.       { 
  2223.           return array_unique($authors); 
  2224.       } 
  2225.       else 
  2226.       { 
  2227.           return null; 
  2228.       } 
  2229.   } 
  2230.  
  2231.   /** 
  2232.    * Get a contributor for the feed 
  2233.    * 
  2234.    * @since 1.1 
  2235.    * @param int $key The contrbutor that you want to return.  Remember that arrays begin with 0, not 1 
  2236.    * @return SimplePie_Author|null 
  2237.    */ 
  2238.   public function get_contributor($key = 0) 
  2239.   { 
  2240.       $contributors = $this->get_contributors(); 
  2241.       if (isset($contributors[$key])) 
  2242.       { 
  2243.           return $contributors[$key]; 
  2244.       } 
  2245.       else 
  2246.       { 
  2247.           return null; 
  2248.       } 
  2249.   } 
  2250.  
  2251.   /** 
  2252.    * Get all contributors for the feed 
  2253.    * 
  2254.    * Uses `<atom:contributor>` 
  2255.    * 
  2256.    * @since 1.1 
  2257.    * @return array|null List of {@see SimplePie_Author} objects 
  2258.    */ 
  2259.   public function get_contributors() 
  2260.   { 
  2261.       $contributors = array(); 
  2262.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor) 
  2263.       { 
  2264.           $name = null; 
  2265.           $uri = null; 
  2266.           $email = null; 
  2267.           if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'])) 
  2268.           { 
  2269.               $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2270.           } 
  2271.           if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'])) 
  2272.           { 
  2273.               $uri = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0])); 
  2274.           } 
  2275.           if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'])) 
  2276.           { 
  2277.               $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2278.           } 
  2279.           if ($name !== null || $email !== null || $uri !== null) 
  2280.           { 
  2281.               $contributors[] = $this->registry->create('Author', array($name, $uri, $email)); 
  2282.           } 
  2283.       } 
  2284.       foreach ((array) $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor) 
  2285.       { 
  2286.           $name = null; 
  2287.           $url = null; 
  2288.           $email = null; 
  2289.           if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'])) 
  2290.           { 
  2291.               $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2292.           } 
  2293.           if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'])) 
  2294.           { 
  2295.               $url = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0])); 
  2296.           } 
  2297.           if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'])) 
  2298.           { 
  2299.               $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2300.           } 
  2301.           if ($name !== null || $email !== null || $url !== null) 
  2302.           { 
  2303.               $contributors[] = $this->registry->create('Author', array($name, $url, $email)); 
  2304.           } 
  2305.       } 
  2306.  
  2307.       if (!empty($contributors)) 
  2308.       { 
  2309.           return array_unique($contributors); 
  2310.       } 
  2311.       else 
  2312.       { 
  2313.           return null; 
  2314.       } 
  2315.   } 
  2316.  
  2317.   /** 
  2318.    * Get a single link for the feed 
  2319.    * 
  2320.    * @since 1.0 (previously called `get_feed_link` since Preview Release, `get_feed_permalink()` since 0.8) 
  2321.    * @param int $key The link that you want to return.  Remember that arrays begin with 0, not 1 
  2322.    * @param string $rel The relationship of the link to return 
  2323.    * @return string|null Link URL 
  2324.    */ 
  2325.   public function get_link($key = 0, $rel = 'alternate') 
  2326.   { 
  2327.       $links = $this->get_links($rel); 
  2328.       if (isset($links[$key])) 
  2329.       { 
  2330.           return $links[$key]; 
  2331.       } 
  2332.       else 
  2333.       { 
  2334.           return null; 
  2335.       } 
  2336.   } 
  2337.  
  2338.   /** 
  2339.    * Get the permalink for the item 
  2340.    * 
  2341.    * Returns the first link available with a relationship of "alternate". 
  2342.    * Identical to {@see get_link()} with key 0 
  2343.    * 
  2344.    * @see get_link 
  2345.    * @since 1.0 (previously called `get_feed_link` since Preview Release, `get_feed_permalink()` since 0.8) 
  2346.    * @internal Added for parity between the parent-level and the item/entry-level. 
  2347.    * @return string|null Link URL 
  2348.    */ 
  2349.   public function get_permalink() 
  2350.   { 
  2351.       return $this->get_link(0); 
  2352.   } 
  2353.  
  2354.   /** 
  2355.    * Get all links for the feed 
  2356.    * 
  2357.    * Uses `<atom:link>` or `<link>` 
  2358.    * 
  2359.    * @since Beta 2 
  2360.    * @param string $rel The relationship of links to return 
  2361.    * @return array|null Links found for the feed (strings) 
  2362.    */ 
  2363.   public function get_links($rel = 'alternate') 
  2364.   { 
  2365.       if (!isset($this->data['links'])) 
  2366.       { 
  2367.           $this->data['links'] = array(); 
  2368.           if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link')) 
  2369.           { 
  2370.               foreach ($links as $link) 
  2371.               { 
  2372.                   if (isset($link['attribs']['']['href'])) 
  2373.                   { 
  2374.                       $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate'; 
  2375.                       $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); 
  2376.                   } 
  2377.               } 
  2378.           } 
  2379.           if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link')) 
  2380.           { 
  2381.               foreach ($links as $link) 
  2382.               { 
  2383.                   if (isset($link['attribs']['']['href'])) 
  2384.                   { 
  2385.                       $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate'; 
  2386.                       $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link)); 
  2387.  
  2388.                   } 
  2389.               } 
  2390.           } 
  2391.           if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link')) 
  2392.           { 
  2393.               $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); 
  2394.           } 
  2395.           if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link')) 
  2396.           { 
  2397.               $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); 
  2398.           } 
  2399.           if ($links = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link')) 
  2400.           { 
  2401.               $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0])); 
  2402.           } 
  2403.  
  2404.           $keys = array_keys($this->data['links']); 
  2405.           foreach ($keys as $key) 
  2406.           { 
  2407.               if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key))) 
  2408.               { 
  2409.                   if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key])) 
  2410.                   { 
  2411.                       $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]); 
  2412.                       $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]; 
  2413.                   } 
  2414.                   else 
  2415.                   { 
  2416.                       $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key]; 
  2417.                   } 
  2418.               } 
  2419.               elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY) 
  2420.               { 
  2421.                   $this->data['links'][substr($key, 41)] =& $this->data['links'][$key]; 
  2422.               } 
  2423.               $this->data['links'][$key] = array_unique($this->data['links'][$key]); 
  2424.           } 
  2425.       } 
  2426.  
  2427.       if (isset($this->data['links'][$rel])) 
  2428.       { 
  2429.           return $this->data['links'][$rel]; 
  2430.       } 
  2431.       else 
  2432.       { 
  2433.           return null; 
  2434.       } 
  2435.   } 
  2436.  
  2437.   public function get_all_discovered_feeds() 
  2438.   { 
  2439.       return $this->all_discovered_feeds; 
  2440.   } 
  2441.  
  2442.   /** 
  2443.    * Get the content for the item 
  2444.    * 
  2445.    * Uses `<atom:subtitle>`, `<atom:tagline>`, `<description>`,  
  2446.    * `<dc:description>`, `<itunes:summary>` or `<itunes:subtitle>` 
  2447.    * 
  2448.    * @since 1.0 (previously called `get_feed_description()` since 0.8) 
  2449.    * @return string|null 
  2450.    */ 
  2451.   public function get_description() 
  2452.   { 
  2453.       if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'subtitle')) 
  2454.       { 
  2455.           return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 
  2456.       } 
  2457.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'tagline')) 
  2458.       { 
  2459.           return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 
  2460.       } 
  2461.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description')) 
  2462.       { 
  2463.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 
  2464.       } 
  2465.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description')) 
  2466.       { 
  2467.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0])); 
  2468.       } 
  2469.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description')) 
  2470.       { 
  2471.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); 
  2472.       } 
  2473.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description')) 
  2474.       { 
  2475.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2476.       } 
  2477.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description')) 
  2478.       { 
  2479.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2480.       } 
  2481.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary')) 
  2482.       { 
  2483.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); 
  2484.       } 
  2485.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle')) 
  2486.       { 
  2487.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0])); 
  2488.       } 
  2489.       else 
  2490.       { 
  2491.           return null; 
  2492.       } 
  2493.   } 
  2494.  
  2495.   /** 
  2496.    * Get the copyright info for the feed 
  2497.    * 
  2498.    * Uses `<atom:rights>`, `<atom:copyright>` or `<dc:rights>` 
  2499.    * 
  2500.    * @since 1.0 (previously called `get_feed_copyright()` since 0.8) 
  2501.    * @return string|null 
  2502.    */ 
  2503.   public function get_copyright() 
  2504.   { 
  2505.       if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights')) 
  2506.       { 
  2507.           return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 
  2508.       } 
  2509.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'copyright')) 
  2510.       { 
  2511.           return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0])); 
  2512.       } 
  2513.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'copyright')) 
  2514.       { 
  2515.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2516.       } 
  2517.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights')) 
  2518.       { 
  2519.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2520.       } 
  2521.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights')) 
  2522.       { 
  2523.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2524.       } 
  2525.       else 
  2526.       { 
  2527.           return null; 
  2528.       } 
  2529.   } 
  2530.  
  2531.   /** 
  2532.    * Get the language for the feed 
  2533.    * 
  2534.    * Uses `<language>`, `<dc:language>`, or @xml_lang 
  2535.    * 
  2536.    * @since 1.0 (previously called `get_feed_language()` since 0.8) 
  2537.    * @return string|null 
  2538.    */ 
  2539.   public function get_language() 
  2540.   { 
  2541.       if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'language')) 
  2542.       { 
  2543.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2544.       } 
  2545.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_11, 'language')) 
  2546.       { 
  2547.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2548.       } 
  2549.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_DC_10, 'language')) 
  2550.       { 
  2551.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2552.       } 
  2553.       elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['xml_lang'])) 
  2554.       { 
  2555.           return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['feed'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2556.       } 
  2557.       elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['xml_lang'])) 
  2558.       { 
  2559.           return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['feed'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2560.       } 
  2561.       elseif (isset($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['xml_lang'])) 
  2562.       { 
  2563.           return $this->sanitize($this->data['child'][SIMPLEPIE_NAMESPACE_RDF]['RDF'][0]['xml_lang'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2564.       } 
  2565.       elseif (isset($this->data['headers']['content-language'])) 
  2566.       { 
  2567.           return $this->sanitize($this->data['headers']['content-language'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2568.       } 
  2569.       else 
  2570.       { 
  2571.           return null; 
  2572.       } 
  2573.   } 
  2574.  
  2575.   /** 
  2576.    * Get the latitude coordinates for the item 
  2577.    * 
  2578.    * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications 
  2579.    * 
  2580.    * Uses `<geo:lat>` or `<georss:point>` 
  2581.    * 
  2582.    * @since 1.0 
  2583.    * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo 
  2584.    * @link http://www.georss.org/ GeoRSS 
  2585.    * @return string|null 
  2586.    */ 
  2587.   public function get_latitude() 
  2588.   { 
  2589.  
  2590.       if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat')) 
  2591.       { 
  2592.           return (float) $return[0]['data']; 
  2593.       } 
  2594.       elseif (($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match)) 
  2595.       { 
  2596.           return (float) $match[1]; 
  2597.       } 
  2598.       else 
  2599.       { 
  2600.           return null; 
  2601.       } 
  2602.   } 
  2603.  
  2604.   /** 
  2605.    * Get the longitude coordinates for the feed 
  2606.    * 
  2607.    * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications 
  2608.    * 
  2609.    * Uses `<geo:long>`, `<geo:lon>` or `<georss:point>` 
  2610.    * 
  2611.    * @since 1.0 
  2612.    * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo 
  2613.    * @link http://www.georss.org/ GeoRSS 
  2614.    * @return string|null 
  2615.    */ 
  2616.   public function get_longitude() 
  2617.   { 
  2618.       if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long')) 
  2619.       { 
  2620.           return (float) $return[0]['data']; 
  2621.       } 
  2622.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon')) 
  2623.       { 
  2624.           return (float) $return[0]['data']; 
  2625.       } 
  2626.       elseif (($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match)) 
  2627.       { 
  2628.           return (float) $match[2]; 
  2629.       } 
  2630.       else 
  2631.       { 
  2632.           return null; 
  2633.       } 
  2634.   } 
  2635.  
  2636.   /** 
  2637.    * Get the feed logo's title 
  2638.    * 
  2639.    * RSS 0.9.0, 1.0 and 2.0 feeds are allowed to have a "feed logo" title. 
  2640.    * 
  2641.    * Uses `<image><title>` or `<image><dc:title>` 
  2642.    * 
  2643.    * @return string|null 
  2644.    */ 
  2645.   public function get_image_title() 
  2646.   { 
  2647.       if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title')) 
  2648.       { 
  2649.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2650.       } 
  2651.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title')) 
  2652.       { 
  2653.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2654.       } 
  2655.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title')) 
  2656.       { 
  2657.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2658.       } 
  2659.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title')) 
  2660.       { 
  2661.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2662.       } 
  2663.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title')) 
  2664.       { 
  2665.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT); 
  2666.       } 
  2667.       else 
  2668.       { 
  2669.           return null; 
  2670.       } 
  2671.   } 
  2672.  
  2673.   /** 
  2674.    * Get the feed logo's URL 
  2675.    * 
  2676.    * RSS 0.9.0, 2.0, Atom 1.0, and feeds with iTunes RSS tags are allowed to 
  2677.    * have a "feed logo" URL. This points directly to the image itself. 
  2678.    * 
  2679.    * Uses `<itunes:image>`, `<atom:logo>`, `<atom:icon>`,  
  2680.    * `<image><title>` or `<image><dc:title>` 
  2681.    * 
  2682.    * @return string|null 
  2683.    */ 
  2684.   public function get_image_url() 
  2685.   { 
  2686.       if ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'image')) 
  2687.       { 
  2688.           return $this->sanitize($return[0]['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI); 
  2689.       } 
  2690.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'logo')) 
  2691.       { 
  2692.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 
  2693.       } 
  2694.       elseif ($return = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'icon')) 
  2695.       { 
  2696.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 
  2697.       } 
  2698.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'url')) 
  2699.       { 
  2700.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 
  2701.       } 
  2702.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'url')) 
  2703.       { 
  2704.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 
  2705.       } 
  2706.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) 
  2707.       { 
  2708.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 
  2709.       } 
  2710.       else 
  2711.       { 
  2712.           return null; 
  2713.       } 
  2714.   } 
  2715.  
  2716.  
  2717.   /** 
  2718.    * Get the feed logo's link 
  2719.    * 
  2720.    * RSS 0.9.0, 1.0 and 2.0 feeds are allowed to have a "feed logo" link. This 
  2721.    * points to a human-readable page that the image should link to. 
  2722.    * 
  2723.    * Uses `<itunes:image>`, `<atom:logo>`, `<atom:icon>`,  
  2724.    * `<image><title>` or `<image><dc:title>` 
  2725.    * 
  2726.    * @return string|null 
  2727.    */ 
  2728.   public function get_image_link() 
  2729.   { 
  2730.       if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link')) 
  2731.       { 
  2732.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 
  2733.       } 
  2734.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link')) 
  2735.       { 
  2736.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 
  2737.       } 
  2738.       elseif ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link')) 
  2739.       { 
  2740.           return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($return[0])); 
  2741.       } 
  2742.       else 
  2743.       { 
  2744.           return null; 
  2745.       } 
  2746.   } 
  2747.  
  2748.   /** 
  2749.    * Get the feed logo's link 
  2750.    * 
  2751.    * RSS 2.0 feeds are allowed to have a "feed logo" width. 
  2752.    * 
  2753.    * Uses `<image><width>` or defaults to 88.0 if no width is specified and 
  2754.    * the feed is an RSS 2.0 feed. 
  2755.    * 
  2756.    * @return int|float|null 
  2757.    */ 
  2758.   public function get_image_width() 
  2759.   { 
  2760.       if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'width')) 
  2761.       { 
  2762.           return round($return[0]['data']); 
  2763.       } 
  2764.       elseif ($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION && $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) 
  2765.       { 
  2766.           return 88.0; 
  2767.       } 
  2768.       else 
  2769.       { 
  2770.           return null; 
  2771.       } 
  2772.   } 
  2773.  
  2774.   /** 
  2775.    * Get the feed logo's height 
  2776.    * 
  2777.    * RSS 2.0 feeds are allowed to have a "feed logo" height. 
  2778.    * 
  2779.    * Uses `<image><height>` or defaults to 31.0 if no height is specified and 
  2780.    * the feed is an RSS 2.0 feed. 
  2781.    * 
  2782.    * @return int|float|null 
  2783.    */ 
  2784.   public function get_image_height() 
  2785.   { 
  2786.       if ($return = $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'height')) 
  2787.       { 
  2788.           return round($return[0]['data']); 
  2789.       } 
  2790.       elseif ($this->get_type() & SIMPLEPIE_TYPE_RSS_SYNDICATION && $this->get_image_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'url')) 
  2791.       { 
  2792.           return 31.0; 
  2793.       } 
  2794.       else 
  2795.       { 
  2796.           return null; 
  2797.       } 
  2798.   } 
  2799.  
  2800.   /** 
  2801.    * Get the number of items in the feed 
  2802.    * 
  2803.    * This is well-suited for {@link http://php.net/for for()} loops with 
  2804.    * {@see get_item()} 
  2805.    * 
  2806.    * @param int $max Maximum value to return. 0 for no limit 
  2807.    * @return int Number of items in the feed 
  2808.    */ 
  2809.   public function get_item_quantity($max = 0) 
  2810.   { 
  2811.       $max = (int) $max; 
  2812.       $qty = count($this->get_items()); 
  2813.       if ($max === 0) 
  2814.       { 
  2815.           return $qty; 
  2816.       } 
  2817.       else 
  2818.       { 
  2819.           return ($qty > $max) ? $max : $qty; 
  2820.       } 
  2821.   } 
  2822.  
  2823.   /** 
  2824.    * Get a single item from the feed 
  2825.    * 
  2826.    * This is better suited for {@link http://php.net/for for()} loops, whereas 
  2827.    * {@see get_items()} is better suited for 
  2828.    * {@link http://php.net/foreach foreach()} loops. 
  2829.    * 
  2830.    * @see get_item_quantity() 
  2831.    * @since Beta 2 
  2832.    * @param int $key The item that you want to return.  Remember that arrays begin with 0, not 1 
  2833.    * @return SimplePie_Item|null 
  2834.    */ 
  2835.   public function get_item($key = 0) 
  2836.   { 
  2837.       $items = $this->get_items(); 
  2838.       if (isset($items[$key])) 
  2839.       { 
  2840.           return $items[$key]; 
  2841.       } 
  2842.       else 
  2843.       { 
  2844.           return null; 
  2845.       } 
  2846.   } 
  2847.  
  2848.   /** 
  2849.    * Get all items from the feed 
  2850.    * 
  2851.    * This is better suited for {@link http://php.net/for for()} loops, whereas 
  2852.    * {@see get_items()} is better suited for 
  2853.    * {@link http://php.net/foreach foreach()} loops. 
  2854.    * 
  2855.    * @see get_item_quantity 
  2856.    * @since Beta 2 
  2857.    * @param int $start Index to start at 
  2858.    * @param int $end Number of items to return. 0 for all items after `$start` 
  2859.    * @return array|null List of {@see SimplePie_Item} objects 
  2860.    */ 
  2861.   public function get_items($start = 0, $end = 0) 
  2862.   { 
  2863.       if (!isset($this->data['items'])) 
  2864.       { 
  2865.           if (!empty($this->multifeed_objects)) 
  2866.           { 
  2867.               $this->data['items'] = SimplePie::merge_items($this->multifeed_objects, $start, $end, $this->item_limit); 
  2868.           } 
  2869.           else 
  2870.           { 
  2871.               $this->data['items'] = array(); 
  2872.               if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'entry')) 
  2873.               { 
  2874.                   $keys = array_keys($items); 
  2875.                   foreach ($keys as $key) 
  2876.                   { 
  2877.                       $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 
  2878.                   } 
  2879.               } 
  2880.               if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'entry')) 
  2881.               { 
  2882.                   $keys = array_keys($items); 
  2883.                   foreach ($keys as $key) 
  2884.                   { 
  2885.                       $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 
  2886.                   } 
  2887.               } 
  2888.               if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'item')) 
  2889.               { 
  2890.                   $keys = array_keys($items); 
  2891.                   foreach ($keys as $key) 
  2892.                   { 
  2893.                       $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 
  2894.                   } 
  2895.               } 
  2896.               if ($items = $this->get_feed_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'item')) 
  2897.               { 
  2898.                   $keys = array_keys($items); 
  2899.                   foreach ($keys as $key) 
  2900.                   { 
  2901.                       $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 
  2902.                   } 
  2903.               } 
  2904.               if ($items = $this->get_channel_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'item')) 
  2905.               { 
  2906.                   $keys = array_keys($items); 
  2907.                   foreach ($keys as $key) 
  2908.                   { 
  2909.                       $this->data['items'][] = $this->registry->create('Item', array($this, $items[$key])); 
  2910.                   } 
  2911.               } 
  2912.           } 
  2913.       } 
  2914.  
  2915.       if (!empty($this->data['items'])) 
  2916.       { 
  2917.           // If we want to order it by date, check if all items have a date, and then sort it 
  2918.           if ($this->order_by_date && empty($this->multifeed_objects)) 
  2919.           { 
  2920.               if (!isset($this->data['ordered_items'])) 
  2921.               { 
  2922.                   $do_sort = true; 
  2923.                   foreach ($this->data['items'] as $item) 
  2924.                   { 
  2925.                       if (!$item->get_date('U')) 
  2926.                       { 
  2927.                           $do_sort = false; 
  2928.                           break; 
  2929.                       } 
  2930.                   } 
  2931.                   $item = null; 
  2932.                   $this->data['ordered_items'] = $this->data['items']; 
  2933.                   if ($do_sort) 
  2934.                   { 
  2935.                       usort($this->data['ordered_items'], array(get_class($this), 'sort_items')); 
  2936.                   } 
  2937.               } 
  2938.               $items = $this->data['ordered_items']; 
  2939.           } 
  2940.           else 
  2941.           { 
  2942.               $items = $this->data['items']; 
  2943.           } 
  2944.  
  2945.           // Slice the data as desired 
  2946.           if ($end === 0) 
  2947.           { 
  2948.               return array_slice($items, $start); 
  2949.           } 
  2950.           else 
  2951.           { 
  2952.               return array_slice($items, $start, $end); 
  2953.           } 
  2954.       } 
  2955.       else 
  2956.       { 
  2957.           return array(); 
  2958.       } 
  2959.   } 
  2960.  
  2961.   /** 
  2962.    * Set the favicon handler 
  2963.    * 
  2964.    * @deprecated Use your own favicon handling instead 
  2965.    */ 
  2966.   public function set_favicon_handler($page = false, $qs = 'i') 
  2967.   { 
  2968.       $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 
  2969.       trigger_error('Favicon handling has been removed, please use your own handling', $level); 
  2970.       return false; 
  2971.   } 
  2972.  
  2973.   /** 
  2974.    * Get the favicon for the current feed 
  2975.    * 
  2976.    * @deprecated Use your own favicon handling instead 
  2977.    */ 
  2978.   public function get_favicon() 
  2979.   { 
  2980.       $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 
  2981.       trigger_error('Favicon handling has been removed, please use your own handling', $level); 
  2982.  
  2983.       if (($url = $this->get_link()) !== null) 
  2984.       { 
  2985.           return 'http://g.etfv.co/' . urlencode($url); 
  2986.       } 
  2987.  
  2988.       return false; 
  2989.   } 
  2990.  
  2991.   /** 
  2992.    * Magic method handler 
  2993.    * 
  2994.    * @param string $method Method name 
  2995.    * @param array $args Arguments to the method 
  2996.    * @return mixed 
  2997.    */ 
  2998.   public function __call($method, $args) 
  2999.   { 
  3000.       if (strpos($method, 'subscribe_') === 0) 
  3001.       { 
  3002.           $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 
  3003.           trigger_error('subscribe_*() has been deprecated, implement the callback yourself', $level); 
  3004.           return ''; 
  3005.       } 
  3006.       if ($method === 'enable_xml_dump') 
  3007.       { 
  3008.           $level = defined('E_USER_DEPRECATED') ? E_USER_DEPRECATED : E_USER_WARNING; 
  3009.           trigger_error('enable_xml_dump() has been deprecated, use get_raw_data() instead', $level); 
  3010.           return false; 
  3011.       } 
  3012.  
  3013.       $class = get_class($this); 
  3014.       $trace = debug_backtrace(); 
  3015.       $file = $trace[0]['file']; 
  3016.       $line = $trace[0]['line']; 
  3017.       trigger_error("Call to undefined method $class::$method() in $file on line $line", E_USER_ERROR); 
  3018.   } 
  3019.  
  3020.   /** 
  3021.    * Sorting callback for items 
  3022.    * 
  3023.    * @access private 
  3024.    * @param SimplePie $a 
  3025.    * @param SimplePie $b 
  3026.    * @return boolean 
  3027.    */ 
  3028.   public static function sort_items($a, $b) 
  3029.   { 
  3030.       return $a->get_date('U') <= $b->get_date('U'); 
  3031.   } 
  3032.  
  3033.   /** 
  3034.    * Merge items from several feeds into one 
  3035.    * 
  3036.    * If you're merging multiple feeds together, they need to all have dates 
  3037.    * for the items or else SimplePie will refuse to sort them. 
  3038.    * 
  3039.    * @link http://simplepie.org/wiki/tutorial/sort_multiple_feeds_by_time_and_date#if_feeds_require_separate_per-feed_settings 
  3040.    * @param array $urls List of SimplePie feed objects to merge 
  3041.    * @param int $start Starting item 
  3042.    * @param int $end Number of items to return 
  3043.    * @param int $limit Maximum number of items per feed 
  3044.    * @return array 
  3045.    */ 
  3046.   public static function merge_items($urls, $start = 0, $end = 0, $limit = 0) 
  3047.   { 
  3048.       if (is_array($urls) && sizeof($urls) > 0) 
  3049.       { 
  3050.           $items = array(); 
  3051.           foreach ($urls as $arg) 
  3052.           { 
  3053.               if ($arg instanceof SimplePie) 
  3054.               { 
  3055.                   $items = array_merge($items, $arg->get_items(0, $limit)); 
  3056.               } 
  3057.               else 
  3058.               { 
  3059.                   trigger_error('Arguments must be SimplePie objects', E_USER_WARNING); 
  3060.               } 
  3061.           } 
  3062.  
  3063.           $do_sort = true; 
  3064.           foreach ($items as $item) 
  3065.           { 
  3066.               if (!$item->get_date('U')) 
  3067.               { 
  3068.                   $do_sort = false; 
  3069.                   break; 
  3070.               } 
  3071.           } 
  3072.           $item = null; 
  3073.           if ($do_sort) 
  3074.           { 
  3075.               usort($items, array(get_class($urls[0]), 'sort_items')); 
  3076.           } 
  3077.  
  3078.           if ($end === 0) 
  3079.           { 
  3080.               return array_slice($items, $start); 
  3081.           } 
  3082.           else 
  3083.           { 
  3084.               return array_slice($items, $start, $end); 
  3085.           } 
  3086.       } 
  3087.       else 
  3088.       { 
  3089.           trigger_error('Cannot merge zero SimplePie objects', E_USER_WARNING); 
  3090.           return array(); 
  3091.       } 
  3092.   } 
  3093. } 
  3094. endif; 
.