~canonical-sysadmins/wordpress/4.7.4

« back to all changes in this revision

Viewing changes to wp-includes/SimplePie/Item.php

  • Committer: Jacek Nykis
  • Date: 2015-01-05 16:17:05 UTC
  • Revision ID: jacek.nykis@canonical.com-20150105161705-w544l1h5mcg7u4w9
Initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
<?php
 
2
/**
 
3
 * SimplePie
 
4
 *
 
5
 * A PHP-Based RSS and Atom Feed Framework.
 
6
 * Takes the hard work out of managing a complete RSS/Atom solution.
 
7
 *
 
8
 * Copyright (c) 2004-2012, Ryan Parman, Geoffrey Sneddon, Ryan McCue, and contributors
 
9
 * All rights reserved.
 
10
 *
 
11
 * Redistribution and use in source and binary forms, with or without modification, are
 
12
 * permitted provided that the following conditions are met:
 
13
 *
 
14
 *      * Redistributions of source code must retain the above copyright notice, this list of
 
15
 *        conditions and the following disclaimer.
 
16
 *
 
17
 *      * Redistributions in binary form must reproduce the above copyright notice, this list
 
18
 *        of conditions and the following disclaimer in the documentation and/or other materials
 
19
 *        provided with the distribution.
 
20
 *
 
21
 *      * Neither the name of the SimplePie Team nor the names of its contributors may be used
 
22
 *        to endorse or promote products derived from this software without specific prior
 
23
 *        written permission.
 
24
 *
 
25
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
 
26
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 
27
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
 
28
 * AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 
29
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
30
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
31
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 
32
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 
33
 * POSSIBILITY OF SUCH DAMAGE.
 
34
 *
 
35
 * @package SimplePie
 
36
 * @version 1.3.1
 
37
 * @copyright 2004-2012 Ryan Parman, Geoffrey Sneddon, Ryan McCue
 
38
 * @author Ryan Parman
 
39
 * @author Geoffrey Sneddon
 
40
 * @author Ryan McCue
 
41
 * @link http://simplepie.org/ SimplePie
 
42
 * @license http://www.opensource.org/licenses/bsd-license.php BSD License
 
43
 */
 
44
 
 
45
 
 
46
/**
 
47
 * Manages all item-related data
 
48
 *
 
49
 * Used by {@see SimplePie::get_item()} and {@see SimplePie::get_items()}
 
50
 *
 
51
 * This class can be overloaded with {@see SimplePie::set_item_class()}
 
52
 *
 
53
 * @package SimplePie
 
54
 * @subpackage API
 
55
 */
 
56
class SimplePie_Item
 
57
{
 
58
        /**
 
59
         * Parent feed
 
60
         *
 
61
         * @access private
 
62
         * @var SimplePie
 
63
         */
 
64
        var $feed;
 
65
 
 
66
        /**
 
67
         * Raw data
 
68
         *
 
69
         * @access private
 
70
         * @var array
 
71
         */
 
72
        var $data = array();
 
73
 
 
74
        /**
 
75
         * Registry object
 
76
         *
 
77
         * @see set_registry
 
78
         * @var SimplePie_Registry
 
79
         */
 
80
        protected $registry;
 
81
 
 
82
        /**
 
83
         * Create a new item object
 
84
         *
 
85
         * This is usually used by {@see SimplePie::get_items} and
 
86
         * {@see SimplePie::get_item}. Avoid creating this manually.
 
87
         *
 
88
         * @param SimplePie $feed Parent feed
 
89
         * @param array $data Raw data
 
90
         */
 
91
        public function __construct($feed, $data)
 
92
        {
 
93
                $this->feed = $feed;
 
94
                $this->data = $data;
 
95
        }
 
96
 
 
97
        /**
 
98
         * Set the registry handler
 
99
         *
 
100
         * This is usually used by {@see SimplePie_Registry::create}
 
101
         *
 
102
         * @since 1.3
 
103
         * @param SimplePie_Registry $registry
 
104
         */
 
105
        public function set_registry(SimplePie_Registry $registry)
 
106
        {
 
107
                $this->registry = $registry;
 
108
        }
 
109
 
 
110
        /**
 
111
         * Get a string representation of the item
 
112
         *
 
113
         * @return string
 
114
         */
 
115
        public function __toString()
 
116
        {
 
117
                return md5(serialize($this->data));
 
118
        }
 
119
 
 
120
        /**
 
121
         * Remove items that link back to this before destroying this object
 
122
         */
 
123
        public function __destruct()
 
124
        {
 
125
                if ((version_compare(PHP_VERSION, '5.3', '<') || !gc_enabled()) && !ini_get('zend.ze1_compatibility_mode'))
 
126
                {
 
127
                        unset($this->feed);
 
128
                }
 
129
        }
 
130
 
 
131
        /**
 
132
         * Get data for an item-level element
 
133
         *
 
134
         * This method allows you to get access to ANY element/attribute that is a
 
135
         * sub-element of the item/entry tag.
 
136
         *
 
137
         * See {@see SimplePie::get_feed_tags()} for a description of the return value
 
138
         *
 
139
         * @since 1.0
 
140
         * @see http://simplepie.org/wiki/faq/supported_xml_namespaces
 
141
         * @param string $namespace The URL of the XML namespace of the elements you're trying to access
 
142
         * @param string $tag Tag name
 
143
         * @return array
 
144
         */
 
145
        public function get_item_tags($namespace, $tag)
 
146
        {
 
147
                if (isset($this->data['child'][$namespace][$tag]))
 
148
                {
 
149
                        return $this->data['child'][$namespace][$tag];
 
150
                }
 
151
                else
 
152
                {
 
153
                        return null;
 
154
                }
 
155
        }
 
156
 
 
157
        /**
 
158
         * Get the base URL value from the parent feed
 
159
         *
 
160
         * Uses `<xml:base>`
 
161
         *
 
162
         * @param array $element
 
163
         * @return string
 
164
         */
 
165
        public function get_base($element = array())
 
166
        {
 
167
                return $this->feed->get_base($element);
 
168
        }
 
169
 
 
170
        /**
 
171
         * Sanitize feed data
 
172
         *
 
173
         * @access private
 
174
         * @see SimplePie::sanitize()
 
175
         * @param string $data Data to sanitize
 
176
         * @param int $type One of the SIMPLEPIE_CONSTRUCT_* constants
 
177
         * @param string $base Base URL to resolve URLs against
 
178
         * @return string Sanitized data
 
179
         */
 
180
        public function sanitize($data, $type, $base = '')
 
181
        {
 
182
                return $this->feed->sanitize($data, $type, $base);
 
183
        }
 
184
 
 
185
        /**
 
186
         * Get the parent feed
 
187
         *
 
188
         * Note: this may not work as you think for multifeeds!
 
189
         *
 
190
         * @link http://simplepie.org/faq/typical_multifeed_gotchas#missing_data_from_feed
 
191
         * @since 1.0
 
192
         * @return SimplePie
 
193
         */
 
194
        public function get_feed()
 
195
        {
 
196
                return $this->feed;
 
197
        }
 
198
 
 
199
        /**
 
200
         * Get the unique identifier for the item
 
201
         *
 
202
         * This is usually used when writing code to check for new items in a feed.
 
203
         *
 
204
         * Uses `<atom:id>`, `<guid>`, `<dc:identifier>` or the `about` attribute
 
205
         * for RDF. If none of these are supplied (or `$hash` is true), creates an
 
206
         * MD5 hash based on the permalink and title. If either of those are not
 
207
         * supplied, creates a hash based on the full feed data.
 
208
         *
 
209
         * @since Beta 2
 
210
         * @param boolean $hash Should we force using a hash instead of the supplied ID?
 
211
         * @return string
 
212
         */
 
213
        public function get_id($hash = false)
 
214
        {
 
215
                if (!$hash)
 
216
                {
 
217
                        if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'id'))
 
218
                        {
 
219
                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
220
                        }
 
221
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'id'))
 
222
                        {
 
223
                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
224
                        }
 
225
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'guid'))
 
226
                        {
 
227
                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
228
                        }
 
229
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'identifier'))
 
230
                        {
 
231
                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
232
                        }
 
233
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'identifier'))
 
234
                        {
 
235
                                return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
236
                        }
 
237
                        elseif (isset($this->data['attribs'][SIMPLEPIE_NAMESPACE_RDF]['about']))
 
238
                        {
 
239
                                return $this->sanitize($this->data['attribs'][SIMPLEPIE_NAMESPACE_RDF]['about'], SIMPLEPIE_CONSTRUCT_TEXT);
 
240
                        }
 
241
                        elseif (($return = $this->get_permalink()) !== null)
 
242
                        {
 
243
                                return $return;
 
244
                        }
 
245
                        elseif (($return = $this->get_title()) !== null)
 
246
                        {
 
247
                                return $return;
 
248
                        }
 
249
                }
 
250
                if ($this->get_permalink() !== null || $this->get_title() !== null)
 
251
                {
 
252
                        return md5($this->get_permalink() . $this->get_title());
 
253
                }
 
254
                else
 
255
                {
 
256
                        return md5(serialize($this->data));
 
257
                }
 
258
        }
 
259
 
 
260
        /**
 
261
         * Get the title of the item
 
262
         *
 
263
         * Uses `<atom:title>`, `<title>` or `<dc:title>`
 
264
         *
 
265
         * @since Beta 2 (previously called `get_item_title` since 0.8)
 
266
         * @return string|null
 
267
         */
 
268
        public function get_title()
 
269
        {
 
270
                if (!isset($this->data['title']))
 
271
                {
 
272
                        if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'title'))
 
273
                        {
 
274
                                $this->data['title'] = $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 
275
                        }
 
276
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'title'))
 
277
                        {
 
278
                                $this->data['title'] = $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 
279
                        }
 
280
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'title'))
 
281
                        {
 
282
                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
 
283
                        }
 
284
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'title'))
 
285
                        {
 
286
                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
 
287
                        }
 
288
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'title'))
 
289
                        {
 
290
                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
 
291
                        }
 
292
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'title'))
 
293
                        {
 
294
                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
295
                        }
 
296
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'title'))
 
297
                        {
 
298
                                $this->data['title'] = $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
299
                        }
 
300
                        else
 
301
                        {
 
302
                                $this->data['title'] = null;
 
303
                        }
 
304
                }
 
305
                return $this->data['title'];
 
306
        }
 
307
 
 
308
        /**
 
309
         * Get the content for the item
 
310
         *
 
311
         * Prefers summaries over full content , but will return full content if a
 
312
         * summary does not exist.
 
313
         *
 
314
         * To prefer full content instead, use {@see get_content}
 
315
         *
 
316
         * Uses `<atom:summary>`, `<description>`, `<dc:description>` or
 
317
         * `<itunes:subtitle>`
 
318
         *
 
319
         * @since 0.8
 
320
         * @param boolean $description_only Should we avoid falling back to the content?
 
321
         * @return string|null
 
322
         */
 
323
        public function get_description($description_only = false)
 
324
        {
 
325
                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'summary'))
 
326
                {
 
327
                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 
328
                }
 
329
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'summary'))
 
330
                {
 
331
                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 
332
                }
 
333
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'description'))
 
334
                {
 
335
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_MAYBE_HTML, $this->get_base($return[0]));
 
336
                }
 
337
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'description'))
 
338
                {
 
339
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
 
340
                }
 
341
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'description'))
 
342
                {
 
343
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
344
                }
 
345
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'description'))
 
346
                {
 
347
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
348
                }
 
349
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'summary'))
 
350
                {
 
351
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
 
352
                }
 
353
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'subtitle'))
 
354
                {
 
355
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
356
                }
 
357
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'description'))
 
358
                {
 
359
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML);
 
360
                }
 
361
 
 
362
                elseif (!$description_only)
 
363
                {
 
364
                        return $this->get_content(true);
 
365
                }
 
366
                else
 
367
                {
 
368
                        return null;
 
369
                }
 
370
        }
 
371
 
 
372
        /**
 
373
         * Get the content for the item
 
374
         *
 
375
         * Prefers full content over summaries, but will return a summary if full
 
376
         * content does not exist.
 
377
         *
 
378
         * To prefer summaries instead, use {@see get_description}
 
379
         *
 
380
         * Uses `<atom:content>` or `<content:encoded>` (RSS 1.0 Content Module)
 
381
         *
 
382
         * @since 1.0
 
383
         * @param boolean $content_only Should we avoid falling back to the description?
 
384
         * @return string|null
 
385
         */
 
386
        public function get_content($content_only = false)
 
387
        {
 
388
                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'content'))
 
389
                {
 
390
                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_content_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 
391
                }
 
392
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'content'))
 
393
                {
 
394
                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_03_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 
395
                }
 
396
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10_MODULES_CONTENT, 'encoded'))
 
397
                {
 
398
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_HTML, $this->get_base($return[0]));
 
399
                }
 
400
                elseif (!$content_only)
 
401
                {
 
402
                        return $this->get_description(true);
 
403
                }
 
404
                else
 
405
                {
 
406
                        return null;
 
407
                }
 
408
        }
 
409
 
 
410
        /**
 
411
         * Get a category for the item
 
412
         *
 
413
         * @since Beta 3 (previously called `get_categories()` since Beta 2)
 
414
         * @param int $key The category that you want to return.  Remember that arrays begin with 0, not 1
 
415
         * @return SimplePie_Category|null
 
416
         */
 
417
        public function get_category($key = 0)
 
418
        {
 
419
                $categories = $this->get_categories();
 
420
                if (isset($categories[$key]))
 
421
                {
 
422
                        return $categories[$key];
 
423
                }
 
424
                else
 
425
                {
 
426
                        return null;
 
427
                }
 
428
        }
 
429
 
 
430
        /**
 
431
         * Get all categories for the item
 
432
         *
 
433
         * Uses `<atom:category>`, `<category>` or `<dc:subject>`
 
434
         *
 
435
         * @since Beta 3
 
436
         * @return array|null List of {@see SimplePie_Category} objects
 
437
         */
 
438
        public function get_categories()
 
439
        {
 
440
                $categories = array();
 
441
 
 
442
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'category') as $category)
 
443
                {
 
444
                        $term = null;
 
445
                        $scheme = null;
 
446
                        $label = null;
 
447
                        if (isset($category['attribs']['']['term']))
 
448
                        {
 
449
                                $term = $this->sanitize($category['attribs']['']['term'], SIMPLEPIE_CONSTRUCT_TEXT);
 
450
                        }
 
451
                        if (isset($category['attribs']['']['scheme']))
 
452
                        {
 
453
                                $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
454
                        }
 
455
                        if (isset($category['attribs']['']['label']))
 
456
                        {
 
457
                                $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
 
458
                        }
 
459
                        $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
 
460
                }
 
461
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'category') as $category)
 
462
                {
 
463
                        // This is really the label, but keep this as the term also for BC.
 
464
                        // Label will also work on retrieving because that falls back to term.
 
465
                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
466
                        if (isset($category['attribs']['']['domain']))
 
467
                        {
 
468
                                $scheme = $this->sanitize($category['attribs']['']['domain'], SIMPLEPIE_CONSTRUCT_TEXT);
 
469
                        }
 
470
                        else
 
471
                        {
 
472
                                $scheme = null;
 
473
                        }
 
474
                        $categories[] = $this->registry->create('Category', array($term, $scheme, null));
 
475
                }
 
476
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'subject') as $category)
 
477
                {
 
478
                        $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 
479
                }
 
480
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'subject') as $category)
 
481
                {
 
482
                        $categories[] = $this->registry->create('Category', array($this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 
483
                }
 
484
 
 
485
                if (!empty($categories))
 
486
                {
 
487
                        return array_unique($categories);
 
488
                }
 
489
                else
 
490
                {
 
491
                        return null;
 
492
                }
 
493
        }
 
494
 
 
495
        /**
 
496
         * Get an author for the item
 
497
         *
 
498
         * @since Beta 2
 
499
         * @param int $key The author that you want to return.  Remember that arrays begin with 0, not 1
 
500
         * @return SimplePie_Author|null
 
501
         */
 
502
        public function get_author($key = 0)
 
503
        {
 
504
                $authors = $this->get_authors();
 
505
                if (isset($authors[$key]))
 
506
                {
 
507
                        return $authors[$key];
 
508
                }
 
509
                else
 
510
                {
 
511
                        return null;
 
512
                }
 
513
        }
 
514
 
 
515
        /**
 
516
         * Get a contributor for the item
 
517
         *
 
518
         * @since 1.1
 
519
         * @param int $key The contrbutor that you want to return.  Remember that arrays begin with 0, not 1
 
520
         * @return SimplePie_Author|null
 
521
         */
 
522
        public function get_contributor($key = 0)
 
523
        {
 
524
                $contributors = $this->get_contributors();
 
525
                if (isset($contributors[$key]))
 
526
                {
 
527
                        return $contributors[$key];
 
528
                }
 
529
                else
 
530
                {
 
531
                        return null;
 
532
                }
 
533
        }
 
534
 
 
535
        /**
 
536
         * Get all contributors for the item
 
537
         *
 
538
         * Uses `<atom:contributor>`
 
539
         *
 
540
         * @since 1.1
 
541
         * @return array|null List of {@see SimplePie_Author} objects
 
542
         */
 
543
        public function get_contributors()
 
544
        {
 
545
                $contributors = array();
 
546
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'contributor') as $contributor)
 
547
                {
 
548
                        $name = null;
 
549
                        $uri = null;
 
550
                        $email = null;
 
551
                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
 
552
                        {
 
553
                                $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
554
                        }
 
555
                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
 
556
                        {
 
557
                                $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]));
 
558
                        }
 
559
                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
 
560
                        {
 
561
                                $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
562
                        }
 
563
                        if ($name !== null || $email !== null || $uri !== null)
 
564
                        {
 
565
                                $contributors[] = $this->registry->create('Author', array($name, $uri, $email));
 
566
                        }
 
567
                }
 
568
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'contributor') as $contributor)
 
569
                {
 
570
                        $name = null;
 
571
                        $url = null;
 
572
                        $email = null;
 
573
                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
 
574
                        {
 
575
                                $name = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
576
                        }
 
577
                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
 
578
                        {
 
579
                                $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]));
 
580
                        }
 
581
                        if (isset($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
 
582
                        {
 
583
                                $email = $this->sanitize($contributor['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
584
                        }
 
585
                        if ($name !== null || $email !== null || $url !== null)
 
586
                        {
 
587
                                $contributors[] = $this->registry->create('Author', array($name, $url, $email));
 
588
                        }
 
589
                }
 
590
 
 
591
                if (!empty($contributors))
 
592
                {
 
593
                        return array_unique($contributors);
 
594
                }
 
595
                else
 
596
                {
 
597
                        return null;
 
598
                }
 
599
        }
 
600
 
 
601
        /**
 
602
         * Get all authors for the item
 
603
         *
 
604
         * Uses `<atom:author>`, `<author>`, `<dc:creator>` or `<itunes:author>`
 
605
         *
 
606
         * @since Beta 2
 
607
         * @return array|null List of {@see SimplePie_Author} objects
 
608
         */
 
609
        public function get_authors()
 
610
        {
 
611
                $authors = array();
 
612
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'author') as $author)
 
613
                {
 
614
                        $name = null;
 
615
                        $uri = null;
 
616
                        $email = null;
 
617
                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data']))
 
618
                        {
 
619
                                $name = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
620
                        }
 
621
                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['uri'][0]['data']))
 
622
                        {
 
623
                                $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]));
 
624
                        }
 
625
                        if (isset($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data']))
 
626
                        {
 
627
                                $email = $this->sanitize($author['child'][SIMPLEPIE_NAMESPACE_ATOM_10]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
628
                        }
 
629
                        if ($name !== null || $email !== null || $uri !== null)
 
630
                        {
 
631
                                $authors[] = $this->registry->create('Author', array($name, $uri, $email));
 
632
                        }
 
633
                }
 
634
                if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'author'))
 
635
                {
 
636
                        $name = null;
 
637
                        $url = null;
 
638
                        $email = null;
 
639
                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data']))
 
640
                        {
 
641
                                $name = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['name'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
642
                        }
 
643
                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['url'][0]['data']))
 
644
                        {
 
645
                                $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]));
 
646
                        }
 
647
                        if (isset($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data']))
 
648
                        {
 
649
                                $email = $this->sanitize($author[0]['child'][SIMPLEPIE_NAMESPACE_ATOM_03]['email'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
650
                        }
 
651
                        if ($name !== null || $email !== null || $url !== null)
 
652
                        {
 
653
                                $authors[] = $this->registry->create('Author', array($name, $url, $email));
 
654
                        }
 
655
                }
 
656
                if ($author = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'author'))
 
657
                {
 
658
                        $authors[] = $this->registry->create('Author', array(null, null, $this->sanitize($author[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT)));
 
659
                }
 
660
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'creator') as $author)
 
661
                {
 
662
                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 
663
                }
 
664
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'creator') as $author)
 
665
                {
 
666
                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 
667
                }
 
668
                foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'author') as $author)
 
669
                {
 
670
                        $authors[] = $this->registry->create('Author', array($this->sanitize($author['data'], SIMPLEPIE_CONSTRUCT_TEXT), null, null));
 
671
                }
 
672
 
 
673
                if (!empty($authors))
 
674
                {
 
675
                        return array_unique($authors);
 
676
                }
 
677
                elseif (($source = $this->get_source()) && ($authors = $source->get_authors()))
 
678
                {
 
679
                        return $authors;
 
680
                }
 
681
                elseif ($authors = $this->feed->get_authors())
 
682
                {
 
683
                        return $authors;
 
684
                }
 
685
                else
 
686
                {
 
687
                        return null;
 
688
                }
 
689
        }
 
690
 
 
691
        /**
 
692
         * Get the copyright info for the item
 
693
         *
 
694
         * Uses `<atom:rights>` or `<dc:rights>`
 
695
         *
 
696
         * @since 1.1
 
697
         * @return string
 
698
         */
 
699
        public function get_copyright()
 
700
        {
 
701
                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'rights'))
 
702
                {
 
703
                        return $this->sanitize($return[0]['data'], $this->registry->call('Misc', 'atom_10_construct_type', array($return[0]['attribs'])), $this->get_base($return[0]));
 
704
                }
 
705
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'rights'))
 
706
                {
 
707
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
708
                }
 
709
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'rights'))
 
710
                {
 
711
                        return $this->sanitize($return[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
712
                }
 
713
                else
 
714
                {
 
715
                        return null;
 
716
                }
 
717
        }
 
718
 
 
719
        /**
 
720
         * Get the posting date/time for the item
 
721
         *
 
722
         * Uses `<atom:published>`, `<atom:updated>`, `<atom:issued>`,
 
723
         * `<atom:modified>`, `<pubDate>` or `<dc:date>`
 
724
         *
 
725
         * Note: obeys PHP's timezone setting. To get a UTC date/time, use
 
726
         * {@see get_gmdate}
 
727
         *
 
728
         * @since Beta 2 (previously called `get_item_date` since 0.8)
 
729
         *
 
730
         * @param string $date_format Supports any PHP date format from {@see http://php.net/date} (empty for the raw data)
 
731
         * @return int|string|null
 
732
         */
 
733
        public function get_date($date_format = 'j F Y, g:i a')
 
734
        {
 
735
                if (!isset($this->data['date']))
 
736
                {
 
737
                        if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'published'))
 
738
                        {
 
739
                                $this->data['date']['raw'] = $return[0]['data'];
 
740
                        }
 
741
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'updated'))
 
742
                        {
 
743
                                $this->data['date']['raw'] = $return[0]['data'];
 
744
                        }
 
745
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'issued'))
 
746
                        {
 
747
                                $this->data['date']['raw'] = $return[0]['data'];
 
748
                        }
 
749
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'created'))
 
750
                        {
 
751
                                $this->data['date']['raw'] = $return[0]['data'];
 
752
                        }
 
753
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'modified'))
 
754
                        {
 
755
                                $this->data['date']['raw'] = $return[0]['data'];
 
756
                        }
 
757
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'pubDate'))
 
758
                        {
 
759
                                $this->data['date']['raw'] = $return[0]['data'];
 
760
                        }
 
761
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_11, 'date'))
 
762
                        {
 
763
                                $this->data['date']['raw'] = $return[0]['data'];
 
764
                        }
 
765
                        elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_DC_10, 'date'))
 
766
                        {
 
767
                                $this->data['date']['raw'] = $return[0]['data'];
 
768
                        }
 
769
 
 
770
                        if (!empty($this->data['date']['raw']))
 
771
                        {
 
772
                                $parser = $this->registry->call('Parse_Date', 'get');
 
773
                                $this->data['date']['parsed'] = $parser->parse($this->data['date']['raw']);
 
774
                        }
 
775
                        else
 
776
                        {
 
777
                                $this->data['date'] = null;
 
778
                        }
 
779
                }
 
780
                if ($this->data['date'])
 
781
                {
 
782
                        $date_format = (string) $date_format;
 
783
                        switch ($date_format)
 
784
                        {
 
785
                                case '':
 
786
                                        return $this->sanitize($this->data['date']['raw'], SIMPLEPIE_CONSTRUCT_TEXT);
 
787
 
 
788
                                case 'U':
 
789
                                        return $this->data['date']['parsed'];
 
790
 
 
791
                                default:
 
792
                                        return date($date_format, $this->data['date']['parsed']);
 
793
                        }
 
794
                }
 
795
                else
 
796
                {
 
797
                        return null;
 
798
                }
 
799
        }
 
800
 
 
801
        /**
 
802
         * Get the update date/time for the item
 
803
         *
 
804
         * Uses `<atom:updated>`
 
805
         *
 
806
         * Note: obeys PHP's timezone setting. To get a UTC date/time, use
 
807
         * {@see get_gmdate}
 
808
         *
 
809
         * @param string $date_format Supports any PHP date format from {@see http://php.net/date} (empty for the raw data)
 
810
         * @return int|string|null
 
811
         */
 
812
        public function get_updated_date($date_format = 'j F Y, g:i a')
 
813
        {
 
814
                if (!isset($this->data['updated']))
 
815
                {
 
816
                        if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'updated'))
 
817
                        {
 
818
                                $this->data['updated']['raw'] = $return[0]['data'];
 
819
                        }
 
820
 
 
821
                        if (!empty($this->data['updated']['raw']))
 
822
                        {
 
823
                                $parser = $this->registry->call('Parse_Date', 'get');
 
824
                                $this->data['updated']['parsed'] = $parser->parse($this->data['date']['raw']);
 
825
                        }
 
826
                        else
 
827
                        {
 
828
                                $this->data['updated'] = null;
 
829
                        }
 
830
                }
 
831
                if ($this->data['updated'])
 
832
                {
 
833
                        $date_format = (string) $date_format;
 
834
                        switch ($date_format)
 
835
                        {
 
836
                                case '':
 
837
                                        return $this->sanitize($this->data['updated']['raw'], SIMPLEPIE_CONSTRUCT_TEXT);
 
838
 
 
839
                                case 'U':
 
840
                                        return $this->data['updated']['parsed'];
 
841
 
 
842
                                default:
 
843
                                        return date($date_format, $this->data['updated']['parsed']);
 
844
                        }
 
845
                }
 
846
                else
 
847
                {
 
848
                        return null;
 
849
                }
 
850
        }
 
851
 
 
852
        /**
 
853
         * Get the localized posting date/time for the item
 
854
         *
 
855
         * Returns the date formatted in the localized language. To display in
 
856
         * languages other than the server's default, you need to change the locale
 
857
         * with {@link http://php.net/setlocale setlocale()}. The available
 
858
         * localizations depend on which ones are installed on your web server.
 
859
         *
 
860
         * @since 1.0
 
861
         *
 
862
         * @param string $date_format Supports any PHP date format from {@see http://php.net/strftime} (empty for the raw data)
 
863
         * @return int|string|null
 
864
         */
 
865
        public function get_local_date($date_format = '%c')
 
866
        {
 
867
                if (!$date_format)
 
868
                {
 
869
                        return $this->sanitize($this->get_date(''), SIMPLEPIE_CONSTRUCT_TEXT);
 
870
                }
 
871
                elseif (($date = $this->get_date('U')) !== null && $date !== false)
 
872
                {
 
873
                        return strftime($date_format, $date);
 
874
                }
 
875
                else
 
876
                {
 
877
                        return null;
 
878
                }
 
879
        }
 
880
 
 
881
        /**
 
882
         * Get the posting date/time for the item (UTC time)
 
883
         *
 
884
         * @see get_date
 
885
         * @param string $date_format Supports any PHP date format from {@see http://php.net/date}
 
886
         * @return int|string|null
 
887
         */
 
888
        public function get_gmdate($date_format = 'j F Y, g:i a')
 
889
        {
 
890
                $date = $this->get_date('U');
 
891
                if ($date === null)
 
892
                {
 
893
                        return null;
 
894
                }
 
895
 
 
896
                return gmdate($date_format, $date);
 
897
        }
 
898
 
 
899
        /**
 
900
         * Get the update date/time for the item (UTC time)
 
901
         *
 
902
         * @see get_updated_date
 
903
         * @param string $date_format Supports any PHP date format from {@see http://php.net/date}
 
904
         * @return int|string|null
 
905
         */
 
906
        public function get_updated_gmdate($date_format = 'j F Y, g:i a')
 
907
        {
 
908
                $date = $this->get_updated_date('U');
 
909
                if ($date === null)
 
910
                {
 
911
                        return null;
 
912
                }
 
913
 
 
914
                return gmdate($date_format, $date);
 
915
        }
 
916
 
 
917
        /**
 
918
         * Get the permalink for the item
 
919
         *
 
920
         * Returns the first link available with a relationship of "alternate".
 
921
         * Identical to {@see get_link()} with key 0
 
922
         *
 
923
         * @see get_link
 
924
         * @since 0.8
 
925
         * @return string|null Permalink URL
 
926
         */
 
927
        public function get_permalink()
 
928
        {
 
929
                $link = $this->get_link();
 
930
                $enclosure = $this->get_enclosure(0);
 
931
                if ($link !== null)
 
932
                {
 
933
                        return $link;
 
934
                }
 
935
                elseif ($enclosure !== null)
 
936
                {
 
937
                        return $enclosure->get_link();
 
938
                }
 
939
                else
 
940
                {
 
941
                        return null;
 
942
                }
 
943
        }
 
944
 
 
945
        /**
 
946
         * Get a single link for the item
 
947
         *
 
948
         * @since Beta 3
 
949
         * @param int $key The link that you want to return.  Remember that arrays begin with 0, not 1
 
950
         * @param string $rel The relationship of the link to return
 
951
         * @return string|null Link URL
 
952
         */
 
953
        public function get_link($key = 0, $rel = 'alternate')
 
954
        {
 
955
                $links = $this->get_links($rel);
 
956
                if ($links[$key] !== null)
 
957
                {
 
958
                        return $links[$key];
 
959
                }
 
960
                else
 
961
                {
 
962
                        return null;
 
963
                }
 
964
        }
 
965
 
 
966
        /**
 
967
         * Get all links for the item
 
968
         *
 
969
         * Uses `<atom:link>`, `<link>` or `<guid>`
 
970
         *
 
971
         * @since Beta 2
 
972
         * @param string $rel The relationship of links to return
 
973
         * @return array|null Links found for the item (strings)
 
974
         */
 
975
        public function get_links($rel = 'alternate')
 
976
        {
 
977
                if (!isset($this->data['links']))
 
978
                {
 
979
                        $this->data['links'] = array();
 
980
                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link)
 
981
                        {
 
982
                                if (isset($link['attribs']['']['href']))
 
983
                                {
 
984
                                        $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
 
985
                                        $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
 
986
 
 
987
                                }
 
988
                        }
 
989
                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link') as $link)
 
990
                        {
 
991
                                if (isset($link['attribs']['']['href']))
 
992
                                {
 
993
                                        $link_rel = (isset($link['attribs']['']['rel'])) ? $link['attribs']['']['rel'] : 'alternate';
 
994
                                        $this->data['links'][$link_rel][] = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
 
995
                                }
 
996
                        }
 
997
                        if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_10, 'link'))
 
998
                        {
 
999
                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
 
1000
                        }
 
1001
                        if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_090, 'link'))
 
1002
                        {
 
1003
                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
 
1004
                        }
 
1005
                        if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'link'))
 
1006
                        {
 
1007
                                $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
 
1008
                        }
 
1009
                        if ($links = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'guid'))
 
1010
                        {
 
1011
                                if (!isset($links[0]['attribs']['']['isPermaLink']) || strtolower(trim($links[0]['attribs']['']['isPermaLink'])) === 'true')
 
1012
                                {
 
1013
                                        $this->data['links']['alternate'][] = $this->sanitize($links[0]['data'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($links[0]));
 
1014
                                }
 
1015
                        }
 
1016
 
 
1017
                        $keys = array_keys($this->data['links']);
 
1018
                        foreach ($keys as $key)
 
1019
                        {
 
1020
                                if ($this->registry->call('Misc', 'is_isegment_nz_nc', array($key)))
 
1021
                                {
 
1022
                                        if (isset($this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]))
 
1023
                                        {
 
1024
                                                $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] = array_merge($this->data['links'][$key], $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key]);
 
1025
                                                $this->data['links'][$key] =& $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key];
 
1026
                                        }
 
1027
                                        else
 
1028
                                        {
 
1029
                                                $this->data['links'][SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY . $key] =& $this->data['links'][$key];
 
1030
                                        }
 
1031
                                }
 
1032
                                elseif (substr($key, 0, 41) === SIMPLEPIE_IANA_LINK_RELATIONS_REGISTRY)
 
1033
                                {
 
1034
                                        $this->data['links'][substr($key, 41)] =& $this->data['links'][$key];
 
1035
                                }
 
1036
                                $this->data['links'][$key] = array_unique($this->data['links'][$key]);
 
1037
                        }
 
1038
                }
 
1039
                if (isset($this->data['links'][$rel]))
 
1040
                {
 
1041
                        return $this->data['links'][$rel];
 
1042
                }
 
1043
                else
 
1044
                {
 
1045
                        return null;
 
1046
                }
 
1047
        }
 
1048
 
 
1049
        /**
 
1050
         * Get an enclosure from the item
 
1051
         *
 
1052
         * Supports the <enclosure> RSS tag, as well as Media RSS and iTunes RSS.
 
1053
         *
 
1054
         * @since Beta 2
 
1055
         * @todo Add ability to prefer one type of content over another (in a media group).
 
1056
         * @param int $key The enclosure that you want to return.  Remember that arrays begin with 0, not 1
 
1057
         * @return SimplePie_Enclosure|null
 
1058
         */
 
1059
        public function get_enclosure($key = 0, $prefer = null)
 
1060
        {
 
1061
                $enclosures = $this->get_enclosures();
 
1062
                if (isset($enclosures[$key]))
 
1063
                {
 
1064
                        return $enclosures[$key];
 
1065
                }
 
1066
                else
 
1067
                {
 
1068
                        return null;
 
1069
                }
 
1070
        }
 
1071
 
 
1072
        /**
 
1073
         * Get all available enclosures (podcasts, etc.)
 
1074
         *
 
1075
         * Supports the <enclosure> RSS tag, as well as Media RSS and iTunes RSS.
 
1076
         *
 
1077
         * At this point, we're pretty much assuming that all enclosures for an item
 
1078
         * are the same content.  Anything else is too complicated to
 
1079
         * properly support.
 
1080
         *
 
1081
         * @since Beta 2
 
1082
         * @todo Add support for end-user defined sorting of enclosures by type/handler (so we can prefer the faster-loading FLV over MP4).
 
1083
         * @todo If an element exists at a level, but it's value is empty, we should fall back to the value from the parent (if it exists).
 
1084
         * @return array|null List of SimplePie_Enclosure items
 
1085
         */
 
1086
        public function get_enclosures()
 
1087
        {
 
1088
                if (!isset($this->data['enclosures']))
 
1089
                {
 
1090
                        $this->data['enclosures'] = array();
 
1091
 
 
1092
                        // Elements
 
1093
                        $captions_parent = null;
 
1094
                        $categories_parent = null;
 
1095
                        $copyrights_parent = null;
 
1096
                        $credits_parent = null;
 
1097
                        $description_parent = null;
 
1098
                        $duration_parent = null;
 
1099
                        $hashes_parent = null;
 
1100
                        $keywords_parent = null;
 
1101
                        $player_parent = null;
 
1102
                        $ratings_parent = null;
 
1103
                        $restrictions_parent = null;
 
1104
                        $thumbnails_parent = null;
 
1105
                        $title_parent = null;
 
1106
 
 
1107
                        // Let's do the channel and item-level ones first, and just re-use them if we need to.
 
1108
                        $parent = $this->get_feed();
 
1109
 
 
1110
                        // CAPTIONS
 
1111
                        if ($captions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'text'))
 
1112
                        {
 
1113
                                foreach ($captions as $caption)
 
1114
                                {
 
1115
                                        $caption_type = null;
 
1116
                                        $caption_lang = null;
 
1117
                                        $caption_startTime = null;
 
1118
                                        $caption_endTime = null;
 
1119
                                        $caption_text = null;
 
1120
                                        if (isset($caption['attribs']['']['type']))
 
1121
                                        {
 
1122
                                                $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1123
                                        }
 
1124
                                        if (isset($caption['attribs']['']['lang']))
 
1125
                                        {
 
1126
                                                $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1127
                                        }
 
1128
                                        if (isset($caption['attribs']['']['start']))
 
1129
                                        {
 
1130
                                                $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1131
                                        }
 
1132
                                        if (isset($caption['attribs']['']['end']))
 
1133
                                        {
 
1134
                                                $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1135
                                        }
 
1136
                                        if (isset($caption['data']))
 
1137
                                        {
 
1138
                                                $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1139
                                        }
 
1140
                                        $captions_parent[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
 
1141
                                }
 
1142
                        }
 
1143
                        elseif ($captions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'text'))
 
1144
                        {
 
1145
                                foreach ($captions as $caption)
 
1146
                                {
 
1147
                                        $caption_type = null;
 
1148
                                        $caption_lang = null;
 
1149
                                        $caption_startTime = null;
 
1150
                                        $caption_endTime = null;
 
1151
                                        $caption_text = null;
 
1152
                                        if (isset($caption['attribs']['']['type']))
 
1153
                                        {
 
1154
                                                $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1155
                                        }
 
1156
                                        if (isset($caption['attribs']['']['lang']))
 
1157
                                        {
 
1158
                                                $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1159
                                        }
 
1160
                                        if (isset($caption['attribs']['']['start']))
 
1161
                                        {
 
1162
                                                $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1163
                                        }
 
1164
                                        if (isset($caption['attribs']['']['end']))
 
1165
                                        {
 
1166
                                                $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1167
                                        }
 
1168
                                        if (isset($caption['data']))
 
1169
                                        {
 
1170
                                                $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1171
                                        }
 
1172
                                        $captions_parent[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
 
1173
                                }
 
1174
                        }
 
1175
                        if (is_array($captions_parent))
 
1176
                        {
 
1177
                                $captions_parent = array_values(array_unique($captions_parent));
 
1178
                        }
 
1179
 
 
1180
                        // CATEGORIES
 
1181
                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'category') as $category)
 
1182
                        {
 
1183
                                $term = null;
 
1184
                                $scheme = null;
 
1185
                                $label = null;
 
1186
                                if (isset($category['data']))
 
1187
                                {
 
1188
                                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1189
                                }
 
1190
                                if (isset($category['attribs']['']['scheme']))
 
1191
                                {
 
1192
                                        $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1193
                                }
 
1194
                                else
 
1195
                                {
 
1196
                                        $scheme = 'http://search.yahoo.com/mrss/category_schema';
 
1197
                                }
 
1198
                                if (isset($category['attribs']['']['label']))
 
1199
                                {
 
1200
                                        $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1201
                                }
 
1202
                                $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
 
1203
                        }
 
1204
                        foreach ((array) $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'category') as $category)
 
1205
                        {
 
1206
                                $term = null;
 
1207
                                $scheme = null;
 
1208
                                $label = null;
 
1209
                                if (isset($category['data']))
 
1210
                                {
 
1211
                                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1212
                                }
 
1213
                                if (isset($category['attribs']['']['scheme']))
 
1214
                                {
 
1215
                                        $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1216
                                }
 
1217
                                else
 
1218
                                {
 
1219
                                        $scheme = 'http://search.yahoo.com/mrss/category_schema';
 
1220
                                }
 
1221
                                if (isset($category['attribs']['']['label']))
 
1222
                                {
 
1223
                                        $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1224
                                }
 
1225
                                $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
 
1226
                        }
 
1227
                        foreach ((array) $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'category') as $category)
 
1228
                        {
 
1229
                                $term = null;
 
1230
                                $scheme = 'http://www.itunes.com/dtds/podcast-1.0.dtd';
 
1231
                                $label = null;
 
1232
                                if (isset($category['attribs']['']['text']))
 
1233
                                {
 
1234
                                        $label = $this->sanitize($category['attribs']['']['text'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1235
                                }
 
1236
                                $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
 
1237
 
 
1238
                                if (isset($category['child'][SIMPLEPIE_NAMESPACE_ITUNES]['category']))
 
1239
                                {
 
1240
                                        foreach ((array) $category['child'][SIMPLEPIE_NAMESPACE_ITUNES]['category'] as $subcategory)
 
1241
                                        {
 
1242
                                                if (isset($subcategory['attribs']['']['text']))
 
1243
                                                {
 
1244
                                                        $label = $this->sanitize($subcategory['attribs']['']['text'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1245
                                                }
 
1246
                                                $categories_parent[] = $this->registry->create('Category', array($term, $scheme, $label));
 
1247
                                        }
 
1248
                                }
 
1249
                        }
 
1250
                        if (is_array($categories_parent))
 
1251
                        {
 
1252
                                $categories_parent = array_values(array_unique($categories_parent));
 
1253
                        }
 
1254
 
 
1255
                        // COPYRIGHT
 
1256
                        if ($copyright = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'copyright'))
 
1257
                        {
 
1258
                                $copyright_url = null;
 
1259
                                $copyright_label = null;
 
1260
                                if (isset($copyright[0]['attribs']['']['url']))
 
1261
                                {
 
1262
                                        $copyright_url = $this->sanitize($copyright[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1263
                                }
 
1264
                                if (isset($copyright[0]['data']))
 
1265
                                {
 
1266
                                        $copyright_label = $this->sanitize($copyright[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1267
                                }
 
1268
                                $copyrights_parent = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
 
1269
                        }
 
1270
                        elseif ($copyright = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'copyright'))
 
1271
                        {
 
1272
                                $copyright_url = null;
 
1273
                                $copyright_label = null;
 
1274
                                if (isset($copyright[0]['attribs']['']['url']))
 
1275
                                {
 
1276
                                        $copyright_url = $this->sanitize($copyright[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1277
                                }
 
1278
                                if (isset($copyright[0]['data']))
 
1279
                                {
 
1280
                                        $copyright_label = $this->sanitize($copyright[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1281
                                }
 
1282
                                $copyrights_parent = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
 
1283
                        }
 
1284
 
 
1285
                        // CREDITS
 
1286
                        if ($credits = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'credit'))
 
1287
                        {
 
1288
                                foreach ($credits as $credit)
 
1289
                                {
 
1290
                                        $credit_role = null;
 
1291
                                        $credit_scheme = null;
 
1292
                                        $credit_name = null;
 
1293
                                        if (isset($credit['attribs']['']['role']))
 
1294
                                        {
 
1295
                                                $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1296
                                        }
 
1297
                                        if (isset($credit['attribs']['']['scheme']))
 
1298
                                        {
 
1299
                                                $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1300
                                        }
 
1301
                                        else
 
1302
                                        {
 
1303
                                                $credit_scheme = 'urn:ebu';
 
1304
                                        }
 
1305
                                        if (isset($credit['data']))
 
1306
                                        {
 
1307
                                                $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1308
                                        }
 
1309
                                        $credits_parent[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
 
1310
                                }
 
1311
                        }
 
1312
                        elseif ($credits = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'credit'))
 
1313
                        {
 
1314
                                foreach ($credits as $credit)
 
1315
                                {
 
1316
                                        $credit_role = null;
 
1317
                                        $credit_scheme = null;
 
1318
                                        $credit_name = null;
 
1319
                                        if (isset($credit['attribs']['']['role']))
 
1320
                                        {
 
1321
                                                $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1322
                                        }
 
1323
                                        if (isset($credit['attribs']['']['scheme']))
 
1324
                                        {
 
1325
                                                $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1326
                                        }
 
1327
                                        else
 
1328
                                        {
 
1329
                                                $credit_scheme = 'urn:ebu';
 
1330
                                        }
 
1331
                                        if (isset($credit['data']))
 
1332
                                        {
 
1333
                                                $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1334
                                        }
 
1335
                                        $credits_parent[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
 
1336
                                }
 
1337
                        }
 
1338
                        if (is_array($credits_parent))
 
1339
                        {
 
1340
                                $credits_parent = array_values(array_unique($credits_parent));
 
1341
                        }
 
1342
 
 
1343
                        // DESCRIPTION
 
1344
                        if ($description_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'description'))
 
1345
                        {
 
1346
                                if (isset($description_parent[0]['data']))
 
1347
                                {
 
1348
                                        $description_parent = $this->sanitize($description_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1349
                                }
 
1350
                        }
 
1351
                        elseif ($description_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'description'))
 
1352
                        {
 
1353
                                if (isset($description_parent[0]['data']))
 
1354
                                {
 
1355
                                        $description_parent = $this->sanitize($description_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1356
                                }
 
1357
                        }
 
1358
 
 
1359
                        // DURATION
 
1360
                        if ($duration_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'duration'))
 
1361
                        {
 
1362
                                $seconds = null;
 
1363
                                $minutes = null;
 
1364
                                $hours = null;
 
1365
                                if (isset($duration_parent[0]['data']))
 
1366
                                {
 
1367
                                        $temp = explode(':', $this->sanitize($duration_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
 
1368
                                        if (sizeof($temp) > 0)
 
1369
                                        {
 
1370
                                                $seconds = (int) array_pop($temp);
 
1371
                                        }
 
1372
                                        if (sizeof($temp) > 0)
 
1373
                                        {
 
1374
                                                $minutes = (int) array_pop($temp);
 
1375
                                                $seconds += $minutes * 60;
 
1376
                                        }
 
1377
                                        if (sizeof($temp) > 0)
 
1378
                                        {
 
1379
                                                $hours = (int) array_pop($temp);
 
1380
                                                $seconds += $hours * 3600;
 
1381
                                        }
 
1382
                                        unset($temp);
 
1383
                                        $duration_parent = $seconds;
 
1384
                                }
 
1385
                        }
 
1386
 
 
1387
                        // HASHES
 
1388
                        if ($hashes_iterator = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'hash'))
 
1389
                        {
 
1390
                                foreach ($hashes_iterator as $hash)
 
1391
                                {
 
1392
                                        $value = null;
 
1393
                                        $algo = null;
 
1394
                                        if (isset($hash['data']))
 
1395
                                        {
 
1396
                                                $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1397
                                        }
 
1398
                                        if (isset($hash['attribs']['']['algo']))
 
1399
                                        {
 
1400
                                                $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1401
                                        }
 
1402
                                        else
 
1403
                                        {
 
1404
                                                $algo = 'md5';
 
1405
                                        }
 
1406
                                        $hashes_parent[] = $algo.':'.$value;
 
1407
                                }
 
1408
                        }
 
1409
                        elseif ($hashes_iterator = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'hash'))
 
1410
                        {
 
1411
                                foreach ($hashes_iterator as $hash)
 
1412
                                {
 
1413
                                        $value = null;
 
1414
                                        $algo = null;
 
1415
                                        if (isset($hash['data']))
 
1416
                                        {
 
1417
                                                $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1418
                                        }
 
1419
                                        if (isset($hash['attribs']['']['algo']))
 
1420
                                        {
 
1421
                                                $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1422
                                        }
 
1423
                                        else
 
1424
                                        {
 
1425
                                                $algo = 'md5';
 
1426
                                        }
 
1427
                                        $hashes_parent[] = $algo.':'.$value;
 
1428
                                }
 
1429
                        }
 
1430
                        if (is_array($hashes_parent))
 
1431
                        {
 
1432
                                $hashes_parent = array_values(array_unique($hashes_parent));
 
1433
                        }
 
1434
 
 
1435
                        // KEYWORDS
 
1436
                        if ($keywords = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'keywords'))
 
1437
                        {
 
1438
                                if (isset($keywords[0]['data']))
 
1439
                                {
 
1440
                                        $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
 
1441
                                        foreach ($temp as $word)
 
1442
                                        {
 
1443
                                                $keywords_parent[] = trim($word);
 
1444
                                        }
 
1445
                                }
 
1446
                                unset($temp);
 
1447
                        }
 
1448
                        elseif ($keywords = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'keywords'))
 
1449
                        {
 
1450
                                if (isset($keywords[0]['data']))
 
1451
                                {
 
1452
                                        $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
 
1453
                                        foreach ($temp as $word)
 
1454
                                        {
 
1455
                                                $keywords_parent[] = trim($word);
 
1456
                                        }
 
1457
                                }
 
1458
                                unset($temp);
 
1459
                        }
 
1460
                        elseif ($keywords = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'keywords'))
 
1461
                        {
 
1462
                                if (isset($keywords[0]['data']))
 
1463
                                {
 
1464
                                        $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
 
1465
                                        foreach ($temp as $word)
 
1466
                                        {
 
1467
                                                $keywords_parent[] = trim($word);
 
1468
                                        }
 
1469
                                }
 
1470
                                unset($temp);
 
1471
                        }
 
1472
                        elseif ($keywords = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'keywords'))
 
1473
                        {
 
1474
                                if (isset($keywords[0]['data']))
 
1475
                                {
 
1476
                                        $temp = explode(',', $this->sanitize($keywords[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
 
1477
                                        foreach ($temp as $word)
 
1478
                                        {
 
1479
                                                $keywords_parent[] = trim($word);
 
1480
                                        }
 
1481
                                }
 
1482
                                unset($temp);
 
1483
                        }
 
1484
                        if (is_array($keywords_parent))
 
1485
                        {
 
1486
                                $keywords_parent = array_values(array_unique($keywords_parent));
 
1487
                        }
 
1488
 
 
1489
                        // PLAYER
 
1490
                        if ($player_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'player'))
 
1491
                        {
 
1492
                                if (isset($player_parent[0]['attribs']['']['url']))
 
1493
                                {
 
1494
                                        $player_parent = $this->sanitize($player_parent[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
1495
                                }
 
1496
                        }
 
1497
                        elseif ($player_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'player'))
 
1498
                        {
 
1499
                                if (isset($player_parent[0]['attribs']['']['url']))
 
1500
                                {
 
1501
                                        $player_parent = $this->sanitize($player_parent[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
1502
                                }
 
1503
                        }
 
1504
 
 
1505
                        // RATINGS
 
1506
                        if ($ratings = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'rating'))
 
1507
                        {
 
1508
                                foreach ($ratings as $rating)
 
1509
                                {
 
1510
                                        $rating_scheme = null;
 
1511
                                        $rating_value = null;
 
1512
                                        if (isset($rating['attribs']['']['scheme']))
 
1513
                                        {
 
1514
                                                $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1515
                                        }
 
1516
                                        else
 
1517
                                        {
 
1518
                                                $rating_scheme = 'urn:simple';
 
1519
                                        }
 
1520
                                        if (isset($rating['data']))
 
1521
                                        {
 
1522
                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1523
                                        }
 
1524
                                        $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
 
1525
                                }
 
1526
                        }
 
1527
                        elseif ($ratings = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'explicit'))
 
1528
                        {
 
1529
                                foreach ($ratings as $rating)
 
1530
                                {
 
1531
                                        $rating_scheme = 'urn:itunes';
 
1532
                                        $rating_value = null;
 
1533
                                        if (isset($rating['data']))
 
1534
                                        {
 
1535
                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1536
                                        }
 
1537
                                        $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
 
1538
                                }
 
1539
                        }
 
1540
                        elseif ($ratings = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'rating'))
 
1541
                        {
 
1542
                                foreach ($ratings as $rating)
 
1543
                                {
 
1544
                                        $rating_scheme = null;
 
1545
                                        $rating_value = null;
 
1546
                                        if (isset($rating['attribs']['']['scheme']))
 
1547
                                        {
 
1548
                                                $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1549
                                        }
 
1550
                                        else
 
1551
                                        {
 
1552
                                                $rating_scheme = 'urn:simple';
 
1553
                                        }
 
1554
                                        if (isset($rating['data']))
 
1555
                                        {
 
1556
                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1557
                                        }
 
1558
                                        $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
 
1559
                                }
 
1560
                        }
 
1561
                        elseif ($ratings = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'explicit'))
 
1562
                        {
 
1563
                                foreach ($ratings as $rating)
 
1564
                                {
 
1565
                                        $rating_scheme = 'urn:itunes';
 
1566
                                        $rating_value = null;
 
1567
                                        if (isset($rating['data']))
 
1568
                                        {
 
1569
                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1570
                                        }
 
1571
                                        $ratings_parent[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
 
1572
                                }
 
1573
                        }
 
1574
                        if (is_array($ratings_parent))
 
1575
                        {
 
1576
                                $ratings_parent = array_values(array_unique($ratings_parent));
 
1577
                        }
 
1578
 
 
1579
                        // RESTRICTIONS
 
1580
                        if ($restrictions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'restriction'))
 
1581
                        {
 
1582
                                foreach ($restrictions as $restriction)
 
1583
                                {
 
1584
                                        $restriction_relationship = null;
 
1585
                                        $restriction_type = null;
 
1586
                                        $restriction_value = null;
 
1587
                                        if (isset($restriction['attribs']['']['relationship']))
 
1588
                                        {
 
1589
                                                $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1590
                                        }
 
1591
                                        if (isset($restriction['attribs']['']['type']))
 
1592
                                        {
 
1593
                                                $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1594
                                        }
 
1595
                                        if (isset($restriction['data']))
 
1596
                                        {
 
1597
                                                $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1598
                                        }
 
1599
                                        $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
 
1600
                                }
 
1601
                        }
 
1602
                        elseif ($restrictions = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'block'))
 
1603
                        {
 
1604
                                foreach ($restrictions as $restriction)
 
1605
                                {
 
1606
                                        $restriction_relationship = 'allow';
 
1607
                                        $restriction_type = null;
 
1608
                                        $restriction_value = 'itunes';
 
1609
                                        if (isset($restriction['data']) && strtolower($restriction['data']) === 'yes')
 
1610
                                        {
 
1611
                                                $restriction_relationship = 'deny';
 
1612
                                        }
 
1613
                                        $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
 
1614
                                }
 
1615
                        }
 
1616
                        elseif ($restrictions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'restriction'))
 
1617
                        {
 
1618
                                foreach ($restrictions as $restriction)
 
1619
                                {
 
1620
                                        $restriction_relationship = null;
 
1621
                                        $restriction_type = null;
 
1622
                                        $restriction_value = null;
 
1623
                                        if (isset($restriction['attribs']['']['relationship']))
 
1624
                                        {
 
1625
                                                $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1626
                                        }
 
1627
                                        if (isset($restriction['attribs']['']['type']))
 
1628
                                        {
 
1629
                                                $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1630
                                        }
 
1631
                                        if (isset($restriction['data']))
 
1632
                                        {
 
1633
                                                $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1634
                                        }
 
1635
                                        $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
 
1636
                                }
 
1637
                        }
 
1638
                        elseif ($restrictions = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_ITUNES, 'block'))
 
1639
                        {
 
1640
                                foreach ($restrictions as $restriction)
 
1641
                                {
 
1642
                                        $restriction_relationship = 'allow';
 
1643
                                        $restriction_type = null;
 
1644
                                        $restriction_value = 'itunes';
 
1645
                                        if (isset($restriction['data']) && strtolower($restriction['data']) === 'yes')
 
1646
                                        {
 
1647
                                                $restriction_relationship = 'deny';
 
1648
                                        }
 
1649
                                        $restrictions_parent[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
 
1650
                                }
 
1651
                        }
 
1652
                        if (is_array($restrictions_parent))
 
1653
                        {
 
1654
                                $restrictions_parent = array_values(array_unique($restrictions_parent));
 
1655
                        }
 
1656
                        else
 
1657
                        {
 
1658
                                $restrictions_parent = array(new SimplePie_Restriction('allow', null, 'default'));
 
1659
                        }
 
1660
 
 
1661
                        // THUMBNAILS
 
1662
                        if ($thumbnails = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'thumbnail'))
 
1663
                        {
 
1664
                                foreach ($thumbnails as $thumbnail)
 
1665
                                {
 
1666
                                        if (isset($thumbnail['attribs']['']['url']))
 
1667
                                        {
 
1668
                                                $thumbnails_parent[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
1669
                                        }
 
1670
                                }
 
1671
                        }
 
1672
                        elseif ($thumbnails = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'thumbnail'))
 
1673
                        {
 
1674
                                foreach ($thumbnails as $thumbnail)
 
1675
                                {
 
1676
                                        if (isset($thumbnail['attribs']['']['url']))
 
1677
                                        {
 
1678
                                                $thumbnails_parent[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
1679
                                        }
 
1680
                                }
 
1681
                        }
 
1682
 
 
1683
                        // TITLES
 
1684
                        if ($title_parent = $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'title'))
 
1685
                        {
 
1686
                                if (isset($title_parent[0]['data']))
 
1687
                                {
 
1688
                                        $title_parent = $this->sanitize($title_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1689
                                }
 
1690
                        }
 
1691
                        elseif ($title_parent = $parent->get_channel_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'title'))
 
1692
                        {
 
1693
                                if (isset($title_parent[0]['data']))
 
1694
                                {
 
1695
                                        $title_parent = $this->sanitize($title_parent[0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1696
                                }
 
1697
                        }
 
1698
 
 
1699
                        // Clear the memory
 
1700
                        unset($parent);
 
1701
 
 
1702
                        // Attributes
 
1703
                        $bitrate = null;
 
1704
                        $channels = null;
 
1705
                        $duration = null;
 
1706
                        $expression = null;
 
1707
                        $framerate = null;
 
1708
                        $height = null;
 
1709
                        $javascript = null;
 
1710
                        $lang = null;
 
1711
                        $length = null;
 
1712
                        $medium = null;
 
1713
                        $samplingrate = null;
 
1714
                        $type = null;
 
1715
                        $url = null;
 
1716
                        $width = null;
 
1717
 
 
1718
                        // Elements
 
1719
                        $captions = null;
 
1720
                        $categories = null;
 
1721
                        $copyrights = null;
 
1722
                        $credits = null;
 
1723
                        $description = null;
 
1724
                        $hashes = null;
 
1725
                        $keywords = null;
 
1726
                        $player = null;
 
1727
                        $ratings = null;
 
1728
                        $restrictions = null;
 
1729
                        $thumbnails = null;
 
1730
                        $title = null;
 
1731
 
 
1732
                        // If we have media:group tags, loop through them.
 
1733
                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_MEDIARSS, 'group') as $group)
 
1734
                        {
 
1735
                                if(isset($group['child']) && isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']))
 
1736
                                {
 
1737
                                        // If we have media:content tags, loop through them.
 
1738
                                        foreach ((array) $group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'] as $content)
 
1739
                                        {
 
1740
                                                if (isset($content['attribs']['']['url']))
 
1741
                                                {
 
1742
                                                        // Attributes
 
1743
                                                        $bitrate = null;
 
1744
                                                        $channels = null;
 
1745
                                                        $duration = null;
 
1746
                                                        $expression = null;
 
1747
                                                        $framerate = null;
 
1748
                                                        $height = null;
 
1749
                                                        $javascript = null;
 
1750
                                                        $lang = null;
 
1751
                                                        $length = null;
 
1752
                                                        $medium = null;
 
1753
                                                        $samplingrate = null;
 
1754
                                                        $type = null;
 
1755
                                                        $url = null;
 
1756
                                                        $width = null;
 
1757
 
 
1758
                                                        // Elements
 
1759
                                                        $captions = null;
 
1760
                                                        $categories = null;
 
1761
                                                        $copyrights = null;
 
1762
                                                        $credits = null;
 
1763
                                                        $description = null;
 
1764
                                                        $hashes = null;
 
1765
                                                        $keywords = null;
 
1766
                                                        $player = null;
 
1767
                                                        $ratings = null;
 
1768
                                                        $restrictions = null;
 
1769
                                                        $thumbnails = null;
 
1770
                                                        $title = null;
 
1771
 
 
1772
                                                        // Start checking the attributes of media:content
 
1773
                                                        if (isset($content['attribs']['']['bitrate']))
 
1774
                                                        {
 
1775
                                                                $bitrate = $this->sanitize($content['attribs']['']['bitrate'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1776
                                                        }
 
1777
                                                        if (isset($content['attribs']['']['channels']))
 
1778
                                                        {
 
1779
                                                                $channels = $this->sanitize($content['attribs']['']['channels'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1780
                                                        }
 
1781
                                                        if (isset($content['attribs']['']['duration']))
 
1782
                                                        {
 
1783
                                                                $duration = $this->sanitize($content['attribs']['']['duration'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1784
                                                        }
 
1785
                                                        else
 
1786
                                                        {
 
1787
                                                                $duration = $duration_parent;
 
1788
                                                        }
 
1789
                                                        if (isset($content['attribs']['']['expression']))
 
1790
                                                        {
 
1791
                                                                $expression = $this->sanitize($content['attribs']['']['expression'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1792
                                                        }
 
1793
                                                        if (isset($content['attribs']['']['framerate']))
 
1794
                                                        {
 
1795
                                                                $framerate = $this->sanitize($content['attribs']['']['framerate'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1796
                                                        }
 
1797
                                                        if (isset($content['attribs']['']['height']))
 
1798
                                                        {
 
1799
                                                                $height = $this->sanitize($content['attribs']['']['height'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1800
                                                        }
 
1801
                                                        if (isset($content['attribs']['']['lang']))
 
1802
                                                        {
 
1803
                                                                $lang = $this->sanitize($content['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1804
                                                        }
 
1805
                                                        if (isset($content['attribs']['']['fileSize']))
 
1806
                                                        {
 
1807
                                                                $length = ceil($content['attribs']['']['fileSize']);
 
1808
                                                        }
 
1809
                                                        if (isset($content['attribs']['']['medium']))
 
1810
                                                        {
 
1811
                                                                $medium = $this->sanitize($content['attribs']['']['medium'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1812
                                                        }
 
1813
                                                        if (isset($content['attribs']['']['samplingrate']))
 
1814
                                                        {
 
1815
                                                                $samplingrate = $this->sanitize($content['attribs']['']['samplingrate'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1816
                                                        }
 
1817
                                                        if (isset($content['attribs']['']['type']))
 
1818
                                                        {
 
1819
                                                                $type = $this->sanitize($content['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1820
                                                        }
 
1821
                                                        if (isset($content['attribs']['']['width']))
 
1822
                                                        {
 
1823
                                                                $width = $this->sanitize($content['attribs']['']['width'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1824
                                                        }
 
1825
                                                        $url = $this->sanitize($content['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
1826
 
 
1827
                                                        // Checking the other optional media: elements. Priority: media:content, media:group, item, channel
 
1828
 
 
1829
                                                        // CAPTIONS
 
1830
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
 
1831
                                                        {
 
1832
                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
 
1833
                                                                {
 
1834
                                                                        $caption_type = null;
 
1835
                                                                        $caption_lang = null;
 
1836
                                                                        $caption_startTime = null;
 
1837
                                                                        $caption_endTime = null;
 
1838
                                                                        $caption_text = null;
 
1839
                                                                        if (isset($caption['attribs']['']['type']))
 
1840
                                                                        {
 
1841
                                                                                $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1842
                                                                        }
 
1843
                                                                        if (isset($caption['attribs']['']['lang']))
 
1844
                                                                        {
 
1845
                                                                                $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1846
                                                                        }
 
1847
                                                                        if (isset($caption['attribs']['']['start']))
 
1848
                                                                        {
 
1849
                                                                                $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1850
                                                                        }
 
1851
                                                                        if (isset($caption['attribs']['']['end']))
 
1852
                                                                        {
 
1853
                                                                                $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1854
                                                                        }
 
1855
                                                                        if (isset($caption['data']))
 
1856
                                                                        {
 
1857
                                                                                $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1858
                                                                        }
 
1859
                                                                        $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
 
1860
                                                                }
 
1861
                                                                if (is_array($captions))
 
1862
                                                                {
 
1863
                                                                        $captions = array_values(array_unique($captions));
 
1864
                                                                }
 
1865
                                                        }
 
1866
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
 
1867
                                                        {
 
1868
                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
 
1869
                                                                {
 
1870
                                                                        $caption_type = null;
 
1871
                                                                        $caption_lang = null;
 
1872
                                                                        $caption_startTime = null;
 
1873
                                                                        $caption_endTime = null;
 
1874
                                                                        $caption_text = null;
 
1875
                                                                        if (isset($caption['attribs']['']['type']))
 
1876
                                                                        {
 
1877
                                                                                $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1878
                                                                        }
 
1879
                                                                        if (isset($caption['attribs']['']['lang']))
 
1880
                                                                        {
 
1881
                                                                                $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1882
                                                                        }
 
1883
                                                                        if (isset($caption['attribs']['']['start']))
 
1884
                                                                        {
 
1885
                                                                                $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1886
                                                                        }
 
1887
                                                                        if (isset($caption['attribs']['']['end']))
 
1888
                                                                        {
 
1889
                                                                                $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1890
                                                                        }
 
1891
                                                                        if (isset($caption['data']))
 
1892
                                                                        {
 
1893
                                                                                $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1894
                                                                        }
 
1895
                                                                        $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
 
1896
                                                                }
 
1897
                                                                if (is_array($captions))
 
1898
                                                                {
 
1899
                                                                        $captions = array_values(array_unique($captions));
 
1900
                                                                }
 
1901
                                                        }
 
1902
                                                        else
 
1903
                                                        {
 
1904
                                                                $captions = $captions_parent;
 
1905
                                                        }
 
1906
 
 
1907
                                                        // CATEGORIES
 
1908
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
 
1909
                                                        {
 
1910
                                                                foreach ((array) $content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
 
1911
                                                                {
 
1912
                                                                        $term = null;
 
1913
                                                                        $scheme = null;
 
1914
                                                                        $label = null;
 
1915
                                                                        if (isset($category['data']))
 
1916
                                                                        {
 
1917
                                                                                $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1918
                                                                        }
 
1919
                                                                        if (isset($category['attribs']['']['scheme']))
 
1920
                                                                        {
 
1921
                                                                                $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1922
                                                                        }
 
1923
                                                                        else
 
1924
                                                                        {
 
1925
                                                                                $scheme = 'http://search.yahoo.com/mrss/category_schema';
 
1926
                                                                        }
 
1927
                                                                        if (isset($category['attribs']['']['label']))
 
1928
                                                                        {
 
1929
                                                                                $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1930
                                                                        }
 
1931
                                                                        $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
 
1932
                                                                }
 
1933
                                                        }
 
1934
                                                        if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
 
1935
                                                        {
 
1936
                                                                foreach ((array) $group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
 
1937
                                                                {
 
1938
                                                                        $term = null;
 
1939
                                                                        $scheme = null;
 
1940
                                                                        $label = null;
 
1941
                                                                        if (isset($category['data']))
 
1942
                                                                        {
 
1943
                                                                                $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1944
                                                                        }
 
1945
                                                                        if (isset($category['attribs']['']['scheme']))
 
1946
                                                                        {
 
1947
                                                                                $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1948
                                                                        }
 
1949
                                                                        else
 
1950
                                                                        {
 
1951
                                                                                $scheme = 'http://search.yahoo.com/mrss/category_schema';
 
1952
                                                                        }
 
1953
                                                                        if (isset($category['attribs']['']['label']))
 
1954
                                                                        {
 
1955
                                                                                $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1956
                                                                        }
 
1957
                                                                        $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
 
1958
                                                                }
 
1959
                                                        }
 
1960
                                                        if (is_array($categories) && is_array($categories_parent))
 
1961
                                                        {
 
1962
                                                                $categories = array_values(array_unique(array_merge($categories, $categories_parent)));
 
1963
                                                        }
 
1964
                                                        elseif (is_array($categories))
 
1965
                                                        {
 
1966
                                                                $categories = array_values(array_unique($categories));
 
1967
                                                        }
 
1968
                                                        elseif (is_array($categories_parent))
 
1969
                                                        {
 
1970
                                                                $categories = array_values(array_unique($categories_parent));
 
1971
                                                        }
 
1972
 
 
1973
                                                        // COPYRIGHTS
 
1974
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
 
1975
                                                        {
 
1976
                                                                $copyright_url = null;
 
1977
                                                                $copyright_label = null;
 
1978
                                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
 
1979
                                                                {
 
1980
                                                                        $copyright_url = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1981
                                                                }
 
1982
                                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
 
1983
                                                                {
 
1984
                                                                        $copyright_label = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1985
                                                                }
 
1986
                                                                $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
 
1987
                                                        }
 
1988
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
 
1989
                                                        {
 
1990
                                                                $copyright_url = null;
 
1991
                                                                $copyright_label = null;
 
1992
                                                                if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
 
1993
                                                                {
 
1994
                                                                        $copyright_url = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1995
                                                                }
 
1996
                                                                if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
 
1997
                                                                {
 
1998
                                                                        $copyright_label = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
1999
                                                                }
 
2000
                                                                $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
 
2001
                                                        }
 
2002
                                                        else
 
2003
                                                        {
 
2004
                                                                $copyrights = $copyrights_parent;
 
2005
                                                        }
 
2006
 
 
2007
                                                        // CREDITS
 
2008
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
 
2009
                                                        {
 
2010
                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
 
2011
                                                                {
 
2012
                                                                        $credit_role = null;
 
2013
                                                                        $credit_scheme = null;
 
2014
                                                                        $credit_name = null;
 
2015
                                                                        if (isset($credit['attribs']['']['role']))
 
2016
                                                                        {
 
2017
                                                                                $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2018
                                                                        }
 
2019
                                                                        if (isset($credit['attribs']['']['scheme']))
 
2020
                                                                        {
 
2021
                                                                                $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2022
                                                                        }
 
2023
                                                                        else
 
2024
                                                                        {
 
2025
                                                                                $credit_scheme = 'urn:ebu';
 
2026
                                                                        }
 
2027
                                                                        if (isset($credit['data']))
 
2028
                                                                        {
 
2029
                                                                                $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2030
                                                                        }
 
2031
                                                                        $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
 
2032
                                                                }
 
2033
                                                                if (is_array($credits))
 
2034
                                                                {
 
2035
                                                                        $credits = array_values(array_unique($credits));
 
2036
                                                                }
 
2037
                                                        }
 
2038
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
 
2039
                                                        {
 
2040
                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
 
2041
                                                                {
 
2042
                                                                        $credit_role = null;
 
2043
                                                                        $credit_scheme = null;
 
2044
                                                                        $credit_name = null;
 
2045
                                                                        if (isset($credit['attribs']['']['role']))
 
2046
                                                                        {
 
2047
                                                                                $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2048
                                                                        }
 
2049
                                                                        if (isset($credit['attribs']['']['scheme']))
 
2050
                                                                        {
 
2051
                                                                                $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2052
                                                                        }
 
2053
                                                                        else
 
2054
                                                                        {
 
2055
                                                                                $credit_scheme = 'urn:ebu';
 
2056
                                                                        }
 
2057
                                                                        if (isset($credit['data']))
 
2058
                                                                        {
 
2059
                                                                                $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2060
                                                                        }
 
2061
                                                                        $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
 
2062
                                                                }
 
2063
                                                                if (is_array($credits))
 
2064
                                                                {
 
2065
                                                                        $credits = array_values(array_unique($credits));
 
2066
                                                                }
 
2067
                                                        }
 
2068
                                                        else
 
2069
                                                        {
 
2070
                                                                $credits = $credits_parent;
 
2071
                                                        }
 
2072
 
 
2073
                                                        // DESCRIPTION
 
2074
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
 
2075
                                                        {
 
2076
                                                                $description = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2077
                                                        }
 
2078
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
 
2079
                                                        {
 
2080
                                                                $description = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2081
                                                        }
 
2082
                                                        else
 
2083
                                                        {
 
2084
                                                                $description = $description_parent;
 
2085
                                                        }
 
2086
 
 
2087
                                                        // HASHES
 
2088
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
 
2089
                                                        {
 
2090
                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
 
2091
                                                                {
 
2092
                                                                        $value = null;
 
2093
                                                                        $algo = null;
 
2094
                                                                        if (isset($hash['data']))
 
2095
                                                                        {
 
2096
                                                                                $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2097
                                                                        }
 
2098
                                                                        if (isset($hash['attribs']['']['algo']))
 
2099
                                                                        {
 
2100
                                                                                $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2101
                                                                        }
 
2102
                                                                        else
 
2103
                                                                        {
 
2104
                                                                                $algo = 'md5';
 
2105
                                                                        }
 
2106
                                                                        $hashes[] = $algo.':'.$value;
 
2107
                                                                }
 
2108
                                                                if (is_array($hashes))
 
2109
                                                                {
 
2110
                                                                        $hashes = array_values(array_unique($hashes));
 
2111
                                                                }
 
2112
                                                        }
 
2113
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
 
2114
                                                        {
 
2115
                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
 
2116
                                                                {
 
2117
                                                                        $value = null;
 
2118
                                                                        $algo = null;
 
2119
                                                                        if (isset($hash['data']))
 
2120
                                                                        {
 
2121
                                                                                $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2122
                                                                        }
 
2123
                                                                        if (isset($hash['attribs']['']['algo']))
 
2124
                                                                        {
 
2125
                                                                                $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2126
                                                                        }
 
2127
                                                                        else
 
2128
                                                                        {
 
2129
                                                                                $algo = 'md5';
 
2130
                                                                        }
 
2131
                                                                        $hashes[] = $algo.':'.$value;
 
2132
                                                                }
 
2133
                                                                if (is_array($hashes))
 
2134
                                                                {
 
2135
                                                                        $hashes = array_values(array_unique($hashes));
 
2136
                                                                }
 
2137
                                                        }
 
2138
                                                        else
 
2139
                                                        {
 
2140
                                                                $hashes = $hashes_parent;
 
2141
                                                        }
 
2142
 
 
2143
                                                        // KEYWORDS
 
2144
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
 
2145
                                                        {
 
2146
                                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
 
2147
                                                                {
 
2148
                                                                        $temp = explode(',', $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
 
2149
                                                                        foreach ($temp as $word)
 
2150
                                                                        {
 
2151
                                                                                $keywords[] = trim($word);
 
2152
                                                                        }
 
2153
                                                                        unset($temp);
 
2154
                                                                }
 
2155
                                                                if (is_array($keywords))
 
2156
                                                                {
 
2157
                                                                        $keywords = array_values(array_unique($keywords));
 
2158
                                                                }
 
2159
                                                        }
 
2160
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
 
2161
                                                        {
 
2162
                                                                if (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
 
2163
                                                                {
 
2164
                                                                        $temp = explode(',', $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
 
2165
                                                                        foreach ($temp as $word)
 
2166
                                                                        {
 
2167
                                                                                $keywords[] = trim($word);
 
2168
                                                                        }
 
2169
                                                                        unset($temp);
 
2170
                                                                }
 
2171
                                                                if (is_array($keywords))
 
2172
                                                                {
 
2173
                                                                        $keywords = array_values(array_unique($keywords));
 
2174
                                                                }
 
2175
                                                        }
 
2176
                                                        else
 
2177
                                                        {
 
2178
                                                                $keywords = $keywords_parent;
 
2179
                                                        }
 
2180
 
 
2181
                                                        // PLAYER
 
2182
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
 
2183
                                                        {
 
2184
                                                                $player = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
2185
                                                        }
 
2186
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
 
2187
                                                        {
 
2188
                                                                $player = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
2189
                                                        }
 
2190
                                                        else
 
2191
                                                        {
 
2192
                                                                $player = $player_parent;
 
2193
                                                        }
 
2194
 
 
2195
                                                        // RATINGS
 
2196
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
 
2197
                                                        {
 
2198
                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
 
2199
                                                                {
 
2200
                                                                        $rating_scheme = null;
 
2201
                                                                        $rating_value = null;
 
2202
                                                                        if (isset($rating['attribs']['']['scheme']))
 
2203
                                                                        {
 
2204
                                                                                $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2205
                                                                        }
 
2206
                                                                        else
 
2207
                                                                        {
 
2208
                                                                                $rating_scheme = 'urn:simple';
 
2209
                                                                        }
 
2210
                                                                        if (isset($rating['data']))
 
2211
                                                                        {
 
2212
                                                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2213
                                                                        }
 
2214
                                                                        $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
 
2215
                                                                }
 
2216
                                                                if (is_array($ratings))
 
2217
                                                                {
 
2218
                                                                        $ratings = array_values(array_unique($ratings));
 
2219
                                                                }
 
2220
                                                        }
 
2221
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
 
2222
                                                        {
 
2223
                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
 
2224
                                                                {
 
2225
                                                                        $rating_scheme = null;
 
2226
                                                                        $rating_value = null;
 
2227
                                                                        if (isset($rating['attribs']['']['scheme']))
 
2228
                                                                        {
 
2229
                                                                                $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2230
                                                                        }
 
2231
                                                                        else
 
2232
                                                                        {
 
2233
                                                                                $rating_scheme = 'urn:simple';
 
2234
                                                                        }
 
2235
                                                                        if (isset($rating['data']))
 
2236
                                                                        {
 
2237
                                                                                $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2238
                                                                        }
 
2239
                                                                        $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
 
2240
                                                                }
 
2241
                                                                if (is_array($ratings))
 
2242
                                                                {
 
2243
                                                                        $ratings = array_values(array_unique($ratings));
 
2244
                                                                }
 
2245
                                                        }
 
2246
                                                        else
 
2247
                                                        {
 
2248
                                                                $ratings = $ratings_parent;
 
2249
                                                        }
 
2250
 
 
2251
                                                        // RESTRICTIONS
 
2252
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
 
2253
                                                        {
 
2254
                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
 
2255
                                                                {
 
2256
                                                                        $restriction_relationship = null;
 
2257
                                                                        $restriction_type = null;
 
2258
                                                                        $restriction_value = null;
 
2259
                                                                        if (isset($restriction['attribs']['']['relationship']))
 
2260
                                                                        {
 
2261
                                                                                $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2262
                                                                        }
 
2263
                                                                        if (isset($restriction['attribs']['']['type']))
 
2264
                                                                        {
 
2265
                                                                                $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2266
                                                                        }
 
2267
                                                                        if (isset($restriction['data']))
 
2268
                                                                        {
 
2269
                                                                                $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2270
                                                                        }
 
2271
                                                                        $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
 
2272
                                                                }
 
2273
                                                                if (is_array($restrictions))
 
2274
                                                                {
 
2275
                                                                        $restrictions = array_values(array_unique($restrictions));
 
2276
                                                                }
 
2277
                                                        }
 
2278
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
 
2279
                                                        {
 
2280
                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
 
2281
                                                                {
 
2282
                                                                        $restriction_relationship = null;
 
2283
                                                                        $restriction_type = null;
 
2284
                                                                        $restriction_value = null;
 
2285
                                                                        if (isset($restriction['attribs']['']['relationship']))
 
2286
                                                                        {
 
2287
                                                                                $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2288
                                                                        }
 
2289
                                                                        if (isset($restriction['attribs']['']['type']))
 
2290
                                                                        {
 
2291
                                                                                $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2292
                                                                        }
 
2293
                                                                        if (isset($restriction['data']))
 
2294
                                                                        {
 
2295
                                                                                $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2296
                                                                        }
 
2297
                                                                        $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
 
2298
                                                                }
 
2299
                                                                if (is_array($restrictions))
 
2300
                                                                {
 
2301
                                                                        $restrictions = array_values(array_unique($restrictions));
 
2302
                                                                }
 
2303
                                                        }
 
2304
                                                        else
 
2305
                                                        {
 
2306
                                                                $restrictions = $restrictions_parent;
 
2307
                                                        }
 
2308
 
 
2309
                                                        // THUMBNAILS
 
2310
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
 
2311
                                                        {
 
2312
                                                                foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
 
2313
                                                                {
 
2314
                                                                        $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
2315
                                                                }
 
2316
                                                                if (is_array($thumbnails))
 
2317
                                                                {
 
2318
                                                                        $thumbnails = array_values(array_unique($thumbnails));
 
2319
                                                                }
 
2320
                                                        }
 
2321
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
 
2322
                                                        {
 
2323
                                                                foreach ($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
 
2324
                                                                {
 
2325
                                                                        $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
2326
                                                                }
 
2327
                                                                if (is_array($thumbnails))
 
2328
                                                                {
 
2329
                                                                        $thumbnails = array_values(array_unique($thumbnails));
 
2330
                                                                }
 
2331
                                                        }
 
2332
                                                        else
 
2333
                                                        {
 
2334
                                                                $thumbnails = $thumbnails_parent;
 
2335
                                                        }
 
2336
 
 
2337
                                                        // TITLES
 
2338
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
 
2339
                                                        {
 
2340
                                                                $title = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2341
                                                        }
 
2342
                                                        elseif (isset($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
 
2343
                                                        {
 
2344
                                                                $title = $this->sanitize($group['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2345
                                                        }
 
2346
                                                        else
 
2347
                                                        {
 
2348
                                                                $title = $title_parent;
 
2349
                                                        }
 
2350
 
 
2351
                                                        $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions, $categories, $channels, $copyrights, $credits, $description, $duration, $expression, $framerate, $hashes, $height, $keywords, $lang, $medium, $player, $ratings, $restrictions, $samplingrate, $thumbnails, $title, $width));
 
2352
                                                }
 
2353
                                        }
 
2354
                                }
 
2355
                        }
 
2356
 
 
2357
                        // If we have standalone media:content tags, loop through them.
 
2358
                        if (isset($this->data['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content']))
 
2359
                        {
 
2360
                                foreach ((array) $this->data['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['content'] as $content)
 
2361
                                {
 
2362
                                        if (isset($content['attribs']['']['url']) || isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
 
2363
                                        {
 
2364
                                                // Attributes
 
2365
                                                $bitrate = null;
 
2366
                                                $channels = null;
 
2367
                                                $duration = null;
 
2368
                                                $expression = null;
 
2369
                                                $framerate = null;
 
2370
                                                $height = null;
 
2371
                                                $javascript = null;
 
2372
                                                $lang = null;
 
2373
                                                $length = null;
 
2374
                                                $medium = null;
 
2375
                                                $samplingrate = null;
 
2376
                                                $type = null;
 
2377
                                                $url = null;
 
2378
                                                $width = null;
 
2379
 
 
2380
                                                // Elements
 
2381
                                                $captions = null;
 
2382
                                                $categories = null;
 
2383
                                                $copyrights = null;
 
2384
                                                $credits = null;
 
2385
                                                $description = null;
 
2386
                                                $hashes = null;
 
2387
                                                $keywords = null;
 
2388
                                                $player = null;
 
2389
                                                $ratings = null;
 
2390
                                                $restrictions = null;
 
2391
                                                $thumbnails = null;
 
2392
                                                $title = null;
 
2393
 
 
2394
                                                // Start checking the attributes of media:content
 
2395
                                                if (isset($content['attribs']['']['bitrate']))
 
2396
                                                {
 
2397
                                                        $bitrate = $this->sanitize($content['attribs']['']['bitrate'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2398
                                                }
 
2399
                                                if (isset($content['attribs']['']['channels']))
 
2400
                                                {
 
2401
                                                        $channels = $this->sanitize($content['attribs']['']['channels'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2402
                                                }
 
2403
                                                if (isset($content['attribs']['']['duration']))
 
2404
                                                {
 
2405
                                                        $duration = $this->sanitize($content['attribs']['']['duration'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2406
                                                }
 
2407
                                                else
 
2408
                                                {
 
2409
                                                        $duration = $duration_parent;
 
2410
                                                }
 
2411
                                                if (isset($content['attribs']['']['expression']))
 
2412
                                                {
 
2413
                                                        $expression = $this->sanitize($content['attribs']['']['expression'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2414
                                                }
 
2415
                                                if (isset($content['attribs']['']['framerate']))
 
2416
                                                {
 
2417
                                                        $framerate = $this->sanitize($content['attribs']['']['framerate'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2418
                                                }
 
2419
                                                if (isset($content['attribs']['']['height']))
 
2420
                                                {
 
2421
                                                        $height = $this->sanitize($content['attribs']['']['height'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2422
                                                }
 
2423
                                                if (isset($content['attribs']['']['lang']))
 
2424
                                                {
 
2425
                                                        $lang = $this->sanitize($content['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2426
                                                }
 
2427
                                                if (isset($content['attribs']['']['fileSize']))
 
2428
                                                {
 
2429
                                                        $length = ceil($content['attribs']['']['fileSize']);
 
2430
                                                }
 
2431
                                                if (isset($content['attribs']['']['medium']))
 
2432
                                                {
 
2433
                                                        $medium = $this->sanitize($content['attribs']['']['medium'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2434
                                                }
 
2435
                                                if (isset($content['attribs']['']['samplingrate']))
 
2436
                                                {
 
2437
                                                        $samplingrate = $this->sanitize($content['attribs']['']['samplingrate'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2438
                                                }
 
2439
                                                if (isset($content['attribs']['']['type']))
 
2440
                                                {
 
2441
                                                        $type = $this->sanitize($content['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2442
                                                }
 
2443
                                                if (isset($content['attribs']['']['width']))
 
2444
                                                {
 
2445
                                                        $width = $this->sanitize($content['attribs']['']['width'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2446
                                                }
 
2447
                                                if (isset($content['attribs']['']['url']))
 
2448
                                                {
 
2449
                                                        $url = $this->sanitize($content['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
2450
                                                }
 
2451
                                                // Checking the other optional media: elements. Priority: media:content, media:group, item, channel
 
2452
 
 
2453
                                                // CAPTIONS
 
2454
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text']))
 
2455
                                                {
 
2456
                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['text'] as $caption)
 
2457
                                                        {
 
2458
                                                                $caption_type = null;
 
2459
                                                                $caption_lang = null;
 
2460
                                                                $caption_startTime = null;
 
2461
                                                                $caption_endTime = null;
 
2462
                                                                $caption_text = null;
 
2463
                                                                if (isset($caption['attribs']['']['type']))
 
2464
                                                                {
 
2465
                                                                        $caption_type = $this->sanitize($caption['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2466
                                                                }
 
2467
                                                                if (isset($caption['attribs']['']['lang']))
 
2468
                                                                {
 
2469
                                                                        $caption_lang = $this->sanitize($caption['attribs']['']['lang'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2470
                                                                }
 
2471
                                                                if (isset($caption['attribs']['']['start']))
 
2472
                                                                {
 
2473
                                                                        $caption_startTime = $this->sanitize($caption['attribs']['']['start'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2474
                                                                }
 
2475
                                                                if (isset($caption['attribs']['']['end']))
 
2476
                                                                {
 
2477
                                                                        $caption_endTime = $this->sanitize($caption['attribs']['']['end'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2478
                                                                }
 
2479
                                                                if (isset($caption['data']))
 
2480
                                                                {
 
2481
                                                                        $caption_text = $this->sanitize($caption['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2482
                                                                }
 
2483
                                                                $captions[] = $this->registry->create('Caption', array($caption_type, $caption_lang, $caption_startTime, $caption_endTime, $caption_text));
 
2484
                                                        }
 
2485
                                                        if (is_array($captions))
 
2486
                                                        {
 
2487
                                                                $captions = array_values(array_unique($captions));
 
2488
                                                        }
 
2489
                                                }
 
2490
                                                else
 
2491
                                                {
 
2492
                                                        $captions = $captions_parent;
 
2493
                                                }
 
2494
 
 
2495
                                                // CATEGORIES
 
2496
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category']))
 
2497
                                                {
 
2498
                                                        foreach ((array) $content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['category'] as $category)
 
2499
                                                        {
 
2500
                                                                $term = null;
 
2501
                                                                $scheme = null;
 
2502
                                                                $label = null;
 
2503
                                                                if (isset($category['data']))
 
2504
                                                                {
 
2505
                                                                        $term = $this->sanitize($category['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2506
                                                                }
 
2507
                                                                if (isset($category['attribs']['']['scheme']))
 
2508
                                                                {
 
2509
                                                                        $scheme = $this->sanitize($category['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2510
                                                                }
 
2511
                                                                else
 
2512
                                                                {
 
2513
                                                                        $scheme = 'http://search.yahoo.com/mrss/category_schema';
 
2514
                                                                }
 
2515
                                                                if (isset($category['attribs']['']['label']))
 
2516
                                                                {
 
2517
                                                                        $label = $this->sanitize($category['attribs']['']['label'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2518
                                                                }
 
2519
                                                                $categories[] = $this->registry->create('Category', array($term, $scheme, $label));
 
2520
                                                        }
 
2521
                                                }
 
2522
                                                if (is_array($categories) && is_array($categories_parent))
 
2523
                                                {
 
2524
                                                        $categories = array_values(array_unique(array_merge($categories, $categories_parent)));
 
2525
                                                }
 
2526
                                                elseif (is_array($categories))
 
2527
                                                {
 
2528
                                                        $categories = array_values(array_unique($categories));
 
2529
                                                }
 
2530
                                                elseif (is_array($categories_parent))
 
2531
                                                {
 
2532
                                                        $categories = array_values(array_unique($categories_parent));
 
2533
                                                }
 
2534
                                                else
 
2535
                                                {
 
2536
                                                        $categories = null;
 
2537
                                                }
 
2538
 
 
2539
                                                // COPYRIGHTS
 
2540
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright']))
 
2541
                                                {
 
2542
                                                        $copyright_url = null;
 
2543
                                                        $copyright_label = null;
 
2544
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url']))
 
2545
                                                        {
 
2546
                                                                $copyright_url = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2547
                                                        }
 
2548
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data']))
 
2549
                                                        {
 
2550
                                                                $copyright_label = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['copyright'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2551
                                                        }
 
2552
                                                        $copyrights = $this->registry->create('Copyright', array($copyright_url, $copyright_label));
 
2553
                                                }
 
2554
                                                else
 
2555
                                                {
 
2556
                                                        $copyrights = $copyrights_parent;
 
2557
                                                }
 
2558
 
 
2559
                                                // CREDITS
 
2560
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit']))
 
2561
                                                {
 
2562
                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['credit'] as $credit)
 
2563
                                                        {
 
2564
                                                                $credit_role = null;
 
2565
                                                                $credit_scheme = null;
 
2566
                                                                $credit_name = null;
 
2567
                                                                if (isset($credit['attribs']['']['role']))
 
2568
                                                                {
 
2569
                                                                        $credit_role = $this->sanitize($credit['attribs']['']['role'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2570
                                                                }
 
2571
                                                                if (isset($credit['attribs']['']['scheme']))
 
2572
                                                                {
 
2573
                                                                        $credit_scheme = $this->sanitize($credit['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2574
                                                                }
 
2575
                                                                else
 
2576
                                                                {
 
2577
                                                                        $credit_scheme = 'urn:ebu';
 
2578
                                                                }
 
2579
                                                                if (isset($credit['data']))
 
2580
                                                                {
 
2581
                                                                        $credit_name = $this->sanitize($credit['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2582
                                                                }
 
2583
                                                                $credits[] = $this->registry->create('Credit', array($credit_role, $credit_scheme, $credit_name));
 
2584
                                                        }
 
2585
                                                        if (is_array($credits))
 
2586
                                                        {
 
2587
                                                                $credits = array_values(array_unique($credits));
 
2588
                                                        }
 
2589
                                                }
 
2590
                                                else
 
2591
                                                {
 
2592
                                                        $credits = $credits_parent;
 
2593
                                                }
 
2594
 
 
2595
                                                // DESCRIPTION
 
2596
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description']))
 
2597
                                                {
 
2598
                                                        $description = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['description'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2599
                                                }
 
2600
                                                else
 
2601
                                                {
 
2602
                                                        $description = $description_parent;
 
2603
                                                }
 
2604
 
 
2605
                                                // HASHES
 
2606
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash']))
 
2607
                                                {
 
2608
                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['hash'] as $hash)
 
2609
                                                        {
 
2610
                                                                $value = null;
 
2611
                                                                $algo = null;
 
2612
                                                                if (isset($hash['data']))
 
2613
                                                                {
 
2614
                                                                        $value = $this->sanitize($hash['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2615
                                                                }
 
2616
                                                                if (isset($hash['attribs']['']['algo']))
 
2617
                                                                {
 
2618
                                                                        $algo = $this->sanitize($hash['attribs']['']['algo'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2619
                                                                }
 
2620
                                                                else
 
2621
                                                                {
 
2622
                                                                        $algo = 'md5';
 
2623
                                                                }
 
2624
                                                                $hashes[] = $algo.':'.$value;
 
2625
                                                        }
 
2626
                                                        if (is_array($hashes))
 
2627
                                                        {
 
2628
                                                                $hashes = array_values(array_unique($hashes));
 
2629
                                                        }
 
2630
                                                }
 
2631
                                                else
 
2632
                                                {
 
2633
                                                        $hashes = $hashes_parent;
 
2634
                                                }
 
2635
 
 
2636
                                                // KEYWORDS
 
2637
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords']))
 
2638
                                                {
 
2639
                                                        if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data']))
 
2640
                                                        {
 
2641
                                                                $temp = explode(',', $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['keywords'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT));
 
2642
                                                                foreach ($temp as $word)
 
2643
                                                                {
 
2644
                                                                        $keywords[] = trim($word);
 
2645
                                                                }
 
2646
                                                                unset($temp);
 
2647
                                                        }
 
2648
                                                        if (is_array($keywords))
 
2649
                                                        {
 
2650
                                                                $keywords = array_values(array_unique($keywords));
 
2651
                                                        }
 
2652
                                                }
 
2653
                                                else
 
2654
                                                {
 
2655
                                                        $keywords = $keywords_parent;
 
2656
                                                }
 
2657
 
 
2658
                                                // PLAYER
 
2659
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player']))
 
2660
                                                {
 
2661
                                                        $player = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['player'][0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
2662
                                                }
 
2663
                                                else
 
2664
                                                {
 
2665
                                                        $player = $player_parent;
 
2666
                                                }
 
2667
 
 
2668
                                                // RATINGS
 
2669
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating']))
 
2670
                                                {
 
2671
                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['rating'] as $rating)
 
2672
                                                        {
 
2673
                                                                $rating_scheme = null;
 
2674
                                                                $rating_value = null;
 
2675
                                                                if (isset($rating['attribs']['']['scheme']))
 
2676
                                                                {
 
2677
                                                                        $rating_scheme = $this->sanitize($rating['attribs']['']['scheme'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2678
                                                                }
 
2679
                                                                else
 
2680
                                                                {
 
2681
                                                                        $rating_scheme = 'urn:simple';
 
2682
                                                                }
 
2683
                                                                if (isset($rating['data']))
 
2684
                                                                {
 
2685
                                                                        $rating_value = $this->sanitize($rating['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2686
                                                                }
 
2687
                                                                $ratings[] = $this->registry->create('Rating', array($rating_scheme, $rating_value));
 
2688
                                                        }
 
2689
                                                        if (is_array($ratings))
 
2690
                                                        {
 
2691
                                                                $ratings = array_values(array_unique($ratings));
 
2692
                                                        }
 
2693
                                                }
 
2694
                                                else
 
2695
                                                {
 
2696
                                                        $ratings = $ratings_parent;
 
2697
                                                }
 
2698
 
 
2699
                                                // RESTRICTIONS
 
2700
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction']))
 
2701
                                                {
 
2702
                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['restriction'] as $restriction)
 
2703
                                                        {
 
2704
                                                                $restriction_relationship = null;
 
2705
                                                                $restriction_type = null;
 
2706
                                                                $restriction_value = null;
 
2707
                                                                if (isset($restriction['attribs']['']['relationship']))
 
2708
                                                                {
 
2709
                                                                        $restriction_relationship = $this->sanitize($restriction['attribs']['']['relationship'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2710
                                                                }
 
2711
                                                                if (isset($restriction['attribs']['']['type']))
 
2712
                                                                {
 
2713
                                                                        $restriction_type = $this->sanitize($restriction['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2714
                                                                }
 
2715
                                                                if (isset($restriction['data']))
 
2716
                                                                {
 
2717
                                                                        $restriction_value = $this->sanitize($restriction['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2718
                                                                }
 
2719
                                                                $restrictions[] = $this->registry->create('Restriction', array($restriction_relationship, $restriction_type, $restriction_value));
 
2720
                                                        }
 
2721
                                                        if (is_array($restrictions))
 
2722
                                                        {
 
2723
                                                                $restrictions = array_values(array_unique($restrictions));
 
2724
                                                        }
 
2725
                                                }
 
2726
                                                else
 
2727
                                                {
 
2728
                                                        $restrictions = $restrictions_parent;
 
2729
                                                }
 
2730
 
 
2731
                                                // THUMBNAILS
 
2732
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail']))
 
2733
                                                {
 
2734
                                                        foreach ($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['thumbnail'] as $thumbnail)
 
2735
                                                        {
 
2736
                                                                $thumbnails[] = $this->sanitize($thumbnail['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI);
 
2737
                                                        }
 
2738
                                                        if (is_array($thumbnails))
 
2739
                                                        {
 
2740
                                                                $thumbnails = array_values(array_unique($thumbnails));
 
2741
                                                        }
 
2742
                                                }
 
2743
                                                else
 
2744
                                                {
 
2745
                                                        $thumbnails = $thumbnails_parent;
 
2746
                                                }
 
2747
 
 
2748
                                                // TITLES
 
2749
                                                if (isset($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title']))
 
2750
                                                {
 
2751
                                                        $title = $this->sanitize($content['child'][SIMPLEPIE_NAMESPACE_MEDIARSS]['title'][0]['data'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2752
                                                }
 
2753
                                                else
 
2754
                                                {
 
2755
                                                        $title = $title_parent;
 
2756
                                                }
 
2757
 
 
2758
                                                $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions, $categories, $channels, $copyrights, $credits, $description, $duration, $expression, $framerate, $hashes, $height, $keywords, $lang, $medium, $player, $ratings, $restrictions, $samplingrate, $thumbnails, $title, $width));
 
2759
                                        }
 
2760
                                }
 
2761
                        }
 
2762
 
 
2763
                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'link') as $link)
 
2764
                        {
 
2765
                                if (isset($link['attribs']['']['href']) && !empty($link['attribs']['']['rel']) && $link['attribs']['']['rel'] === 'enclosure')
 
2766
                                {
 
2767
                                        // Attributes
 
2768
                                        $bitrate = null;
 
2769
                                        $channels = null;
 
2770
                                        $duration = null;
 
2771
                                        $expression = null;
 
2772
                                        $framerate = null;
 
2773
                                        $height = null;
 
2774
                                        $javascript = null;
 
2775
                                        $lang = null;
 
2776
                                        $length = null;
 
2777
                                        $medium = null;
 
2778
                                        $samplingrate = null;
 
2779
                                        $type = null;
 
2780
                                        $url = null;
 
2781
                                        $width = null;
 
2782
 
 
2783
                                        $url = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
 
2784
                                        if (isset($link['attribs']['']['type']))
 
2785
                                        {
 
2786
                                                $type = $this->sanitize($link['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2787
                                        }
 
2788
                                        if (isset($link['attribs']['']['length']))
 
2789
                                        {
 
2790
                                                $length = ceil($link['attribs']['']['length']);
 
2791
                                        }
 
2792
 
 
2793
                                        // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
 
2794
                                        $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
 
2795
                                }
 
2796
                        }
 
2797
 
 
2798
                        foreach ((array) $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_03, 'link') as $link)
 
2799
                        {
 
2800
                                if (isset($link['attribs']['']['href']) && !empty($link['attribs']['']['rel']) && $link['attribs']['']['rel'] === 'enclosure')
 
2801
                                {
 
2802
                                        // Attributes
 
2803
                                        $bitrate = null;
 
2804
                                        $channels = null;
 
2805
                                        $duration = null;
 
2806
                                        $expression = null;
 
2807
                                        $framerate = null;
 
2808
                                        $height = null;
 
2809
                                        $javascript = null;
 
2810
                                        $lang = null;
 
2811
                                        $length = null;
 
2812
                                        $medium = null;
 
2813
                                        $samplingrate = null;
 
2814
                                        $type = null;
 
2815
                                        $url = null;
 
2816
                                        $width = null;
 
2817
 
 
2818
                                        $url = $this->sanitize($link['attribs']['']['href'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($link));
 
2819
                                        if (isset($link['attribs']['']['type']))
 
2820
                                        {
 
2821
                                                $type = $this->sanitize($link['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2822
                                        }
 
2823
                                        if (isset($link['attribs']['']['length']))
 
2824
                                        {
 
2825
                                                $length = ceil($link['attribs']['']['length']);
 
2826
                                        }
 
2827
 
 
2828
                                        // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
 
2829
                                        $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
 
2830
                                }
 
2831
                        }
 
2832
 
 
2833
                        if ($enclosure = $this->get_item_tags(SIMPLEPIE_NAMESPACE_RSS_20, 'enclosure'))
 
2834
                        {
 
2835
                                if (isset($enclosure[0]['attribs']['']['url']))
 
2836
                                {
 
2837
                                        // Attributes
 
2838
                                        $bitrate = null;
 
2839
                                        $channels = null;
 
2840
                                        $duration = null;
 
2841
                                        $expression = null;
 
2842
                                        $framerate = null;
 
2843
                                        $height = null;
 
2844
                                        $javascript = null;
 
2845
                                        $lang = null;
 
2846
                                        $length = null;
 
2847
                                        $medium = null;
 
2848
                                        $samplingrate = null;
 
2849
                                        $type = null;
 
2850
                                        $url = null;
 
2851
                                        $width = null;
 
2852
 
 
2853
                                        $url = $this->sanitize($enclosure[0]['attribs']['']['url'], SIMPLEPIE_CONSTRUCT_IRI, $this->get_base($enclosure[0]));
 
2854
                                        if (isset($enclosure[0]['attribs']['']['type']))
 
2855
                                        {
 
2856
                                                $type = $this->sanitize($enclosure[0]['attribs']['']['type'], SIMPLEPIE_CONSTRUCT_TEXT);
 
2857
                                        }
 
2858
                                        if (isset($enclosure[0]['attribs']['']['length']))
 
2859
                                        {
 
2860
                                                $length = ceil($enclosure[0]['attribs']['']['length']);
 
2861
                                        }
 
2862
 
 
2863
                                        // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
 
2864
                                        $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
 
2865
                                }
 
2866
                        }
 
2867
 
 
2868
                        if (sizeof($this->data['enclosures']) === 0 && ($url || $type || $length || $bitrate || $captions_parent || $categories_parent || $channels || $copyrights_parent || $credits_parent || $description_parent || $duration_parent || $expression || $framerate || $hashes_parent || $height || $keywords_parent || $lang || $medium || $player_parent || $ratings_parent || $restrictions_parent || $samplingrate || $thumbnails_parent || $title_parent || $width))
 
2869
                        {
 
2870
                                // Since we don't have group or content for these, we'll just pass the '*_parent' variables directly to the constructor
 
2871
                                $this->data['enclosures'][] = $this->registry->create('Enclosure', array($url, $type, $length, null, $bitrate, $captions_parent, $categories_parent, $channels, $copyrights_parent, $credits_parent, $description_parent, $duration_parent, $expression, $framerate, $hashes_parent, $height, $keywords_parent, $lang, $medium, $player_parent, $ratings_parent, $restrictions_parent, $samplingrate, $thumbnails_parent, $title_parent, $width));
 
2872
                        }
 
2873
 
 
2874
                        $this->data['enclosures'] = array_values(array_unique($this->data['enclosures']));
 
2875
                }
 
2876
                if (!empty($this->data['enclosures']))
 
2877
                {
 
2878
                        return $this->data['enclosures'];
 
2879
                }
 
2880
                else
 
2881
                {
 
2882
                        return null;
 
2883
                }
 
2884
        }
 
2885
 
 
2886
        /**
 
2887
         * Get the latitude coordinates for the item
 
2888
         *
 
2889
         * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications
 
2890
         *
 
2891
         * Uses `<geo:lat>` or `<georss:point>`
 
2892
         *
 
2893
         * @since 1.0
 
2894
         * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo
 
2895
         * @link http://www.georss.org/ GeoRSS
 
2896
         * @return string|null
 
2897
         */
 
2898
        public function get_latitude()
 
2899
        {
 
2900
                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lat'))
 
2901
                {
 
2902
                        return (float) $return[0]['data'];
 
2903
                }
 
2904
                elseif (($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
 
2905
                {
 
2906
                        return (float) $match[1];
 
2907
                }
 
2908
                else
 
2909
                {
 
2910
                        return null;
 
2911
                }
 
2912
        }
 
2913
 
 
2914
        /**
 
2915
         * Get the longitude coordinates for the item
 
2916
         *
 
2917
         * Compatible with the W3C WGS84 Basic Geo and GeoRSS specifications
 
2918
         *
 
2919
         * Uses `<geo:long>`, `<geo:lon>` or `<georss:point>`
 
2920
         *
 
2921
         * @since 1.0
 
2922
         * @link http://www.w3.org/2003/01/geo/ W3C WGS84 Basic Geo
 
2923
         * @link http://www.georss.org/ GeoRSS
 
2924
         * @return string|null
 
2925
         */
 
2926
        public function get_longitude()
 
2927
        {
 
2928
                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'long'))
 
2929
                {
 
2930
                        return (float) $return[0]['data'];
 
2931
                }
 
2932
                elseif ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_W3C_BASIC_GEO, 'lon'))
 
2933
                {
 
2934
                        return (float) $return[0]['data'];
 
2935
                }
 
2936
                elseif (($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_GEORSS, 'point')) && preg_match('/^((?:-)?[0-9]+(?:\.[0-9]+)) ((?:-)?[0-9]+(?:\.[0-9]+))$/', trim($return[0]['data']), $match))
 
2937
                {
 
2938
                        return (float) $match[2];
 
2939
                }
 
2940
                else
 
2941
                {
 
2942
                        return null;
 
2943
                }
 
2944
        }
 
2945
 
 
2946
        /**
 
2947
         * Get the `<atom:source>` for the item
 
2948
         *
 
2949
         * @since 1.1
 
2950
         * @return SimplePie_Source|null
 
2951
         */
 
2952
        public function get_source()
 
2953
        {
 
2954
                if ($return = $this->get_item_tags(SIMPLEPIE_NAMESPACE_ATOM_10, 'source'))
 
2955
                {
 
2956
                        return $this->registry->create('Source', array($this, $return[0]));
 
2957
                }
 
2958
                else
 
2959
                {
 
2960
                        return null;
 
2961
                }
 
2962
        }
 
2963
}
 
2964