1: <?php
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32: if (!defined('XOOPS_ROOT_PATH')) exit();
33:
34: require_once(XOOPS_ROOT_PATH.'/class/xml/saxparser.php');
35: require_once(XOOPS_ROOT_PATH.'/class/xml/xmltaghandler.php');
36:
37: class XoopsXmlRss2Parser extends SaxParser
38: {
39: var $_tempArr = array();
40: var $_channelData = array();
41: var $_imageData = array();
42: var $_items = array();
43:
44: function XoopsXmlRss2Parser(&$input)
45: {
46: $this->SaxParser($input);
47: $this->useUtfEncoding();
48: $this->addTagHandler(new RssChannelHandler());
49: $this->addTagHandler(new RssTitleHandler());
50: $this->addTagHandler(new RssLinkHandler());
51: $this->addTagHandler(new RssGeneratorHandler());
52: $this->addTagHandler(new RssDescriptionHandler());
53: $this->addTagHandler(new RssCopyrightHandler());
54: $this->addTagHandler(new RssNameHandler());
55: $this->addTagHandler(new RssManagingEditorHandler());
56: $this->addTagHandler(new RssLanguageHandler());
57: $this->addTagHandler(new RssLastBuildDateHandler());
58: $this->addTagHandler(new RssWebMasterHandler());
59: $this->addTagHandler(new RssImageHandler());
60: $this->addTagHandler(new RssUrlHandler());
61: $this->addTagHandler(new RssWidthHandler());
62: $this->addTagHandler(new RssHeightHandler());
63: $this->addTagHandler(new RssItemHandler());
64: $this->addTagHandler(new RssCategoryHandler());
65: $this->addTagHandler(new RssPubDateHandler());
66: $this->addTagHandler(new RssCommentsHandler());
67: $this->addTagHandler(new RssSourceHandler());
68: $this->addTagHandler(new RssAuthorHandler());
69: $this->addTagHandler(new RssGuidHandler());
70: $this->addTagHandler(new RssTextInputHandler());
71: }
72:
73: function setChannelData($name, &$value)
74: {
75: if (!isset($this->_channelData[$name])) {
76: $this->_channelData[$name] =& $value;
77: } else {
78: $this->_channelData[$name] .= $value;
79: }
80: }
81:
82: function &getChannelData($name = null)
83: {
84: if (isset($name)) {
85: if (isset($this->_channelData[$name])) {
86: return $this->_channelData[$name];
87: }
88: $ret = false;
89: return $ret;
90: }
91: return $this->_channelData;
92: }
93:
94: function setImageData($name, &$value)
95: {
96: $this->_imageData[$name] =& $value;
97: }
98:
99: function &getImageData($name = null)
100: {
101: if (isset($name)) {
102: if (isset($this->_imageData[$name])) {
103: return $this->_imageData[$name];
104: }
105: $ret = false;
106: return $ret;
107: }
108: return $this->_imageData;
109: }
110:
111: function setItems(&$itemarr)
112: {
113: $this->_items[] =& $itemarr;
114: }
115:
116: function &getItems()
117: {
118: return $this->_items;
119: }
120:
121: function setTempArr($name, &$value, $delim = '')
122: {
123: if (!isset($this->_tempArr[$name])) {
124: $this->_tempArr[$name] =& $value;
125: } else {
126: $this->_tempArr[$name] .= $delim.$value;
127: }
128: }
129:
130: function getTempArr()
131: {
132: return $this->_tempArr;
133: }
134:
135: function resetTempArr()
136: {
137: unset($this->_tempArr);
138: $this->_tempArr = array();
139: }
140: }
141:
142: class RssChannelHandler extends XmlTagHandler
143: {
144:
145: function RssChannelHandler()
146: {
147:
148: }
149:
150: function getName()
151: {
152: return 'channel';
153: }
154: }
155:
156: class RssTitleHandler extends XmlTagHandler
157: {
158:
159: function RssTitleHandler()
160: {
161:
162: }
163:
164: function getName()
165: {
166: return 'title';
167: }
168:
169: function handleCharacterData(&$parser, &$data)
170: {
171: switch ($parser->getParentTag()) {
172: case 'channel':
173: $parser->setChannelData('title', $data);
174: break;
175: case 'image':
176: $parser->setImageData('title', $data);
177: break;
178: case 'item':
179: case 'textInput':
180: $parser->setTempArr('title', $data);
181: break;
182: default:
183: break;
184: }
185: }
186: }
187:
188: class RssLinkHandler extends XmlTagHandler
189: {
190:
191: function RssLinkHandler()
192: {
193:
194: }
195:
196: function getName()
197: {
198: return 'link';
199: }
200:
201: function handleCharacterData(&$parser, &$data)
202: {
203: switch ($parser->getParentTag()) {
204: case 'channel':
205: $parser->setChannelData('link', $data);
206: break;
207: case 'image':
208: $parser->setImageData('link', $data);
209: break;
210: case 'item':
211: case 'textInput':
212: $parser->setTempArr('link', $data);
213: break;
214: default:
215: break;
216: }
217: }
218: }
219:
220: class RssDescriptionHandler extends XmlTagHandler
221: {
222:
223: function RssDescriptionHandler()
224: {
225:
226: }
227:
228: function getName()
229: {
230: return 'description';
231: }
232:
233: function handleCharacterData(&$parser, &$data)
234: {
235: switch ($parser->getParentTag()) {
236: case 'channel':
237: $parser->setChannelData('description', $data);
238: break;
239: case 'image':
240: $parser->setImageData('description', $data);
241: break;
242: case 'item':
243: case 'textInput':
244: $parser->setTempArr('description', $data);
245: break;
246: default:
247: break;
248: }
249: }
250: }
251:
252: class RssGeneratorHandler extends XmlTagHandler
253: {
254:
255: function RssGeneratorHandler()
256: {
257:
258: }
259:
260: function getName()
261: {
262: return 'generator';
263: }
264:
265: function handleCharacterData(&$parser, &$data)
266: {
267: switch ($parser->getParentTag()) {
268: case 'channel':
269: $parser->setChannelData('generator', $data);
270: break;
271: default:
272: break;
273: }
274: }
275: }
276:
277: class RssCopyrightHandler extends XmlTagHandler
278: {
279:
280: function RssCopyrightHandler()
281: {
282:
283: }
284:
285: function getName()
286: {
287: return 'copyright';
288: }
289:
290: function handleCharacterData(&$parser, &$data)
291: {
292: switch ($parser->getParentTag()) {
293: case 'channel':
294: $parser->setChannelData('copyright', $data);
295: break;
296: default:
297: break;
298: }
299: }
300: }
301:
302: class RssNameHandler extends XmlTagHandler
303: {
304:
305: function RssNameHandler()
306: {
307:
308: }
309:
310: function getName()
311: {
312: return 'name';
313: }
314:
315: function handleCharacterData(&$parser, &$data)
316: {
317: switch ($parser->getParentTag()) {
318: case 'textInput':
319: $parser->setTempArr('name', $data);
320: break;
321: default:
322: break;
323: }
324: }
325: }
326:
327: class RssManagingEditorHandler extends XmlTagHandler
328: {
329:
330: function RssManagingEditorHandler()
331: {
332:
333: }
334:
335: function getName()
336: {
337: return 'managingEditor';
338: }
339:
340: function handleCharacterData(&$parser, &$data)
341: {
342: switch ($parser->getParentTag()) {
343: case 'channel':
344: $parser->setChannelData('editor', $data);
345: break;
346: default:
347: break;
348: }
349: }
350: }
351:
352: class RssLanguageHandler extends XmlTagHandler
353: {
354:
355: function RssLanguageHandler()
356: {
357:
358: }
359:
360: function getName()
361: {
362: return 'language';
363: }
364:
365: function handleCharacterData(&$parser, &$data)
366: {
367: switch ($parser->getParentTag()) {
368: case 'channel':
369: $parser->setChannelData('language', $data);
370: break;
371: default:
372: break;
373: }
374: }
375: }
376:
377: class RssWebMasterHandler extends XmlTagHandler
378: {
379:
380: function RssWebMasterHandler()
381: {
382:
383: }
384:
385: function getName()
386: {
387: return 'webMaster';
388: }
389:
390: function handleCharacterData(&$parser, &$data)
391: {
392: switch ($parser->getParentTag()) {
393: case 'channel':
394: $parser->setChannelData('webmaster', $data);
395: break;
396: default:
397: break;
398: }
399: }
400: }
401:
402: class RssDocsHandler extends XmlTagHandler
403: {
404:
405: function RssDocsHandler()
406: {
407:
408: }
409:
410: function getName()
411: {
412: return 'docs';
413: }
414:
415: function handleCharacterData(&$parser, &$data)
416: {
417: switch ($parser->getParentTag()) {
418: case 'channel':
419: $parser->setChannelData('docs', $data);
420: break;
421: default:
422: break;
423: }
424: }
425: }
426:
427: class RssTtlHandler extends XmlTagHandler
428: {
429:
430: function RssTtlHandler()
431: {
432:
433: }
434:
435: function getName()
436: {
437: return 'ttl';
438: }
439:
440: function handleCharacterData(&$parser, &$data)
441: {
442: switch ($parser->getParentTag()) {
443: case 'channel':
444: $parser->setChannelData('ttl', $data);
445: break;
446: default:
447: break;
448: }
449: }
450: }
451:
452: class RssTextInputHandler extends XmlTagHandler
453: {
454:
455: function RssWebMasterHandler()
456: {
457:
458: }
459:
460: function getName()
461: {
462: return 'textInput';
463: }
464:
465: function handleBeginElement(&$parser, &$attributes)
466: {
467: $parser->resetTempArr();
468: }
469:
470: function handleEndElement(&$parser)
471: {
472: $parser->setChannelData('textinput', $parser->getTempArr());
473: }
474: }
475:
476: class RssLastBuildDateHandler extends XmlTagHandler
477: {
478:
479: function RssLastBuildDateHandler()
480: {
481:
482: }
483:
484: function getName()
485: {
486: return 'lastBuildDate';
487: }
488:
489: function handleCharacterData(&$parser, &$data)
490: {
491: switch ($parser->getParentTag()) {
492: case 'channel':
493: $parser->setChannelData('lastbuilddate', $data);
494: break;
495: default:
496: break;
497: }
498: }
499: }
500:
501: class RssImageHandler extends XmlTagHandler
502: {
503:
504: function RssImageHandler()
505: {
506: }
507:
508: function getName()
509: {
510: return 'image';
511: }
512: }
513:
514: class RssUrlHandler extends XmlTagHandler
515: {
516:
517: function RssUrlHandler()
518: {
519:
520: }
521:
522: function getName()
523: {
524: return 'url';
525: }
526:
527: function handleCharacterData(&$parser, &$data)
528: {
529: if ($parser->getParentTag() == 'image') {
530: $parser->setImageData('url', $data);
531: }
532: }
533: }
534:
535: class RssWidthHandler extends XmlTagHandler
536: {
537:
538: function RssWidthHandler()
539: {
540:
541: }
542:
543: function getName()
544: {
545: return 'width';
546: }
547:
548: function handleCharacterData(&$parser, &$data)
549: {
550: if ($parser->getParentTag() == 'image') {
551: $parser->setImageData('width', $data);
552: }
553: }
554: }
555:
556: class RssHeightHandler extends XmlTagHandler
557: {
558:
559: function RssHeightHandler()
560: {
561: }
562:
563: function getName()
564: {
565: return 'height';
566: }
567:
568: function handleCharacterData(&$parser, &$data)
569: {
570: if ($parser->getParentTag() == 'image') {
571: $parser->setImageData('height', $data);
572: }
573: }
574: }
575:
576: class RssItemHandler extends XmlTagHandler
577: {
578:
579: function RssItemHandler()
580: {
581:
582: }
583:
584: function getName()
585: {
586: return 'item';
587: }
588:
589: function handleBeginElement(&$parser, &$attributes)
590: {
591: $parser->resetTempArr();
592: }
593:
594: function handleEndElement(&$parser)
595: {
596: $parser->setItems($parser->getTempArr());
597: }
598: }
599:
600: class RssCategoryHandler extends XmlTagHandler
601: {
602:
603: function RssCategoryHandler()
604: {
605:
606: }
607:
608: function getName()
609: {
610: return 'category';
611: }
612:
613: function handleCharacterData(&$parser, &$data)
614: {
615: switch ($parser->getParentTag()) {
616: case 'channel':
617: $parser->setChannelData('category', $data);
618: break;
619: case 'item':
620: $parser->setTempArr('category', $data, ', ');
621: default:
622: break;
623: }
624: }
625: }
626:
627: class RssCommentsHandler extends XmlTagHandler
628: {
629:
630: function RssCommentsHandler()
631: {
632:
633: }
634:
635: function getName()
636: {
637: return 'comments';
638: }
639:
640: function handleCharacterData(&$parser, &$data)
641: {
642: if ($parser->getParentTag() == 'item') {
643: $parser->setTempArr('comments', $data);
644: }
645: }
646: }
647:
648: class RssPubDateHandler extends XmlTagHandler
649: {
650:
651: function RssPubDateHandler()
652: {
653:
654: }
655:
656: function getName()
657: {
658: return 'pubDate';
659: }
660:
661: function handleCharacterData(&$parser, &$data)
662: {
663: switch ($parser->getParentTag()) {
664: case 'channel':
665: $parser->setChannelData('pubdate', $data);
666: break;
667: case 'item':
668: $parser->setTempArr('pubdate', $data);
669: break;
670: default:
671: break;
672: }
673: }
674: }
675:
676: class RssGuidHandler extends XmlTagHandler
677: {
678:
679: function RssGuidHandler()
680: {
681:
682: }
683:
684: function getName()
685: {
686: return 'guid';
687: }
688:
689: function handleCharacterData(&$parser, &$data)
690: {
691: if ($parser->getParentTag() == 'item') {
692: $parser->setTempArr('guid', $data);
693: }
694: }
695: }
696:
697: class RssAuthorHandler extends XmlTagHandler
698: {
699:
700: function RssGuidHandler()
701: {
702:
703: }
704:
705: function getName()
706: {
707: return 'author';
708: }
709:
710: function handleCharacterData(&$parser, &$data)
711: {
712: if ($parser->getParentTag() == 'item') {
713: $parser->setTempArr('author', $data);
714: }
715: }
716: }
717:
718: class RssSourceHandler extends XmlTagHandler
719: {
720:
721: function RssSourceHandler()
722: {
723:
724: }
725:
726: function getName()
727: {
728: return 'source';
729: }
730:
731: function handleBeginElement(&$parser, &$attributes)
732: {
733: if ($parser->getParentTag() == 'item') {
734: $parser->setTempArr('source_url', $attributes['url']);
735: }
736: }
737:
738: function handleCharacterData(&$parser, &$data)
739: {
740: if ($parser->getParentTag() == 'item') {
741: $parser->setTempArr('source', $data);
742: }
743: }
744: }
745: ?>