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>&amp;</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;