1: <?php
  2: /*
  3:  You may not change or alter any portion of this comment or credits
  4:  of supporting developers from this source code or any supporting source code
  5:  which is considered copyrighted (c) material of the original comment or credit authors.
  6: 
  7:  This program is distributed in the hope that it will be useful,
  8:  but WITHOUT ANY WARRANTY; without even the implied warranty of
  9:  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 10: */
 11: 
 12: /**
 13:  * @copyright       XOOPS Project (http://xoops.org)
 14:  * @license         GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 15:  * @package         class
 16:  * @subpackage      xml
 17:  * @since           1.0.0
 18:  * @author          Kazumi Ono (AKA onokazu)
 19:  * @version         $Id $
 20:  */
 21: 
 22: /**
 23:  * Class RSS Parser
 24:  *
 25:  * This class offers methods to parse RSS Files
 26:  *
 27:  * @link      http://www.xoops.org/ Latest release of this class
 28:  * @package   class
 29:  * @copyright Copyright (c) 2001 xoops.org. All rights reserved.
 30:  * @author    Kazumi Ono <onokazu@xoops.org>
 31:  * @version   $Id$
 32:  * @access    public
 33:  */
 34: class XoopsXmlRpcParser extends SaxParser
 35: {
 36: 
 37:     /**
 38:      * @access protected
 39:      * @var    array
 40:      */
 41:     protected $_param;
 42: 
 43:     /**
 44:      * @access protected
 45:      * @var    string
 46:      */
 47:     protected $_methodName;
 48: 
 49:     /**
 50:      * @access protected
 51:      * @var    array
 52:      */
 53:     protected $_tempName;
 54: 
 55:     /**
 56:      * @access protected
 57:      * @var    array
 58:      */
 59:     protected $_tempValue;
 60: 
 61:     /**
 62:      * @access protected
 63:      * @var    array
 64:      */
 65:     protected $_tempMember;
 66: 
 67:     /**
 68:      * @access protected
 69:      * @var    array
 70:      */
 71:     protected $_tempStruct;
 72: 
 73:     /**
 74:      * @access protected
 75:      * @var    array
 76:      */
 77:     protected $_tempArray;
 78: 
 79:     /**
 80:      * @access protected
 81:      * @var    array
 82:      */
 83:     protected $_workingLevel = array();
 84: 
 85: 
 86:     /**
 87:      * Constructor of the class
 88:      *
 89:      * @param $input
 90:      * @return void
 91:      */
 92:     public function __construct(&$input)
 93:     {
 94:         parent::__construct($input);
 95:         $this->addTagHandler(new RpcMethodNameHandler());
 96:         $this->addTagHandler(new RpcIntHandler());
 97:         $this->addTagHandler(new RpcDoubleHandler());
 98:         $this->addTagHandler(new RpcBooleanHandler());
 99:         $this->addTagHandler(new RpcStringHandler());
100:         $this->addTagHandler(new RpcDateTimeHandler());
101:         $this->addTagHandler(new RpcBase64Handler());
102:         $this->addTagHandler(new RpcNameHandler());
103:         $this->addTagHandler(new RpcValueHandler());
104:         $this->addTagHandler(new RpcMemberHandler());
105:         $this->addTagHandler(new RpcStructHandler());
106:         $this->addTagHandler(new RpcArrayHandler());
107:     }
108: 
109:     /**
110:      * @param string $name
111:      * @return void
112:      */
113:     public function setTempName($name)
114:     {
115:         $this->_tempName[$this->getWorkingLevel()] = $name;
116:     }
117: 
118:     /**
119:      * @return string
120:      */
121:     public function getTempName()
122:     {
123:         return $this->_tempName[$this->getWorkingLevel()];
124:     }
125: 
126:     /**
127:      * @param mixed $value
128:      * @return void
129:      */
130:     public function setTempValue($value)
131:     {
132:         if (is_array($value)) {
133:             settype($this->_tempValue, 'array');
134:             foreach ($value as $k => $v) {
135:                 $this->_tempValue[$k] = $v;
136:             }
137:         } elseif (is_string($value)) {
138:             if (isset($this->_tempValue)) {
139:                 if (is_string($this->_tempValue)) {
140:                     $this->_tempValue .= $value;
141:                 }
142:             } else {
143:                 $this->_tempValue = $value;
144:             }
145:         } else {
146:             $this->_tempValue = $value;
147:         }
148:     }
149: 
150:     /**
151:      * @return array
152:      */
153:     public function getTempValue()
154:     {
155:         return $this->_tempValue;
156:     }
157: 
158:     /**
159:      * @return void
160:      */
161:     public function resetTempValue()
162:     {
163:         $this->_tempValue = null;
164:     }
165: 
166:     /**
167:      * @param string $name
168:      * @param mixed $value
169:      * @return void
170:      */
171:     public function setTempMember($name, $value)
172:     {
173:         $this->_tempMember[$this->getWorkingLevel()][$name] = $value;
174:     }
175: 
176:     /**
177:      * @return mixed
178:      */
179:     public function getTempMember()
180:     {
181:         return $this->_tempMember[$this->getWorkingLevel()];
182:     }
183: 
184:     /**
185:      * @return void
186:      */
187:     public function resetTempMember()
188:     {
189:         $this->_tempMember[$this->getWorkingLevel()] = array();
190:     }
191: 
192:     /**
193:      * @return void
194:      */
195:     public function setWorkingLevel()
196:     {
197:         array_push($this->_workingLevel, $this->getCurrentLevel());
198:     }
199: 
200:     /**
201:      * @return mixed
202:      */
203:     public function getWorkingLevel()
204:     {
205:         return (count($this->_workingLevel) > 0)
206:             ? $this->_workingLevel[count($this->_workingLevel) - 1]
207:             : null;
208:     }
209: 
210:     /**
211:      * @return void
212:      */
213:     public function releaseWorkingLevel()
214:     {
215:         array_pop($this->_workingLevel);
216:     }
217: 
218:     /**
219:      * @param array $member
220:      * @return void
221:      */
222:     public function setTempStruct(array $member)
223:     {
224:         $key = key($member);
225:         $this->_tempStruct[$this->getWorkingLevel()][$key] = $member[$key];
226:     }
227: 
228:     /**
229:      * @return
230:      */
231:     public function getTempStruct()
232:     {
233:         return $this->_tempStruct[$this->getWorkingLevel()];
234:     }
235: 
236:     /**
237:      * @return void
238:      */
239:     public function resetTempStruct()
240:     {
241:         $this->_tempStruct[$this->getWorkingLevel()] = array();
242:     }
243: 
244:     /**
245:      * @param mixed $value
246:      * @return void
247:      */
248:     public function setTempArray($value)
249:     {
250:         $this->_tempArray[$this->getWorkingLevel()][] = $value;
251:     }
252: 
253:     /**
254:      * @return
255:      */
256:     public function getTempArray()
257:     {
258:         return $this->_tempArray[$this->getWorkingLevel()];
259:     }
260: 
261:     /**
262:      * @return void
263:      */
264:     public function resetTempArray()
265:     {
266:         $this->_tempArray[$this->getWorkingLevel()] = array();
267:     }
268: 
269:     /**
270:      * @param string $methodName
271:      * @return void
272:      */
273:     public function setMethodName($methodName)
274:     {
275:         $this->_methodName = $methodName;
276:     }
277: 
278:     /**
279:      * @return string
280:      */
281:     public function getMethodName()
282:     {
283:         return $this->_methodName;
284:     }
285: 
286:     /**
287:      * @param mixed $value
288:      * @return void
289:      */
290:     public function setParam($value)
291:     {
292:         $this->_param[] = $value;
293:     }
294: 
295:     /**
296:      * @return array
297:      */
298:     public function getParam()
299:     {
300:         return $this->_param;
301:     }
302: }
303: 
304: 
305: class RpcMethodNameHandler extends XmlTagHandler
306: {
307: 
308:     /**
309:      * @return string
310:      */
311:     public function getName()
312:     {
313:         return 'methodName';
314:     }
315: 
316:     /**
317:      * @param SaxParser $parser
318:      * @param $data
319:      * @return void
320:      */
321:     public function handleCharacterData(SaxParser $parser, &$data)
322:     {
323:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
324:         $parser->setMethodName($data);
325:     }
326: }
327: 
328: class RpcIntHandler extends XmlTagHandler
329: {
330: 
331:     /**
332:     * @return string[]
333:     */
334:     public function getName()
335:     {
336:         return array('int', 'i4');
337:     }
338: 
339:     /**
340:      * @param SaxParser $parser
341:      * @param $data
342:      * @return void
343:      */
344:     public function handleCharacterData(SaxParser $parser, &$data)
345:     {
346:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
347:         $parser->setTempValue((int)($data));
348:     }
349: }
350: 
351: class RpcDoubleHandler extends XmlTagHandler
352: {
353: 
354:     /**
355:      * @return string
356:      */
357:     public function getName()
358:     {
359:         return 'double';
360:     }
361: 
362:     /**
363:      * @param SaxParser $parser
364:      * @param $data
365:      * @return void
366:      */
367:     public function handleCharacterData(SaxParser $parser, &$data)
368:     {
369:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
370:         $data = (float)$data;
371:         $parser->setTempValue($data);
372:     }
373: }
374: 
375: class RpcBooleanHandler extends XmlTagHandler
376: {
377: 
378:     /**
379:      * @return string
380:      */
381:     public function getName()
382:     {
383:         return 'boolean';
384:     }
385: 
386:     /**
387:      * @param SaxParser $parser
388:      * @param $data
389:      * @return void
390:      */
391:     public function handleCharacterData(SaxParser $parser, &$data)
392:     {
393:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
394:         $data = (boolean)$data;
395:         $parser->setTempValue($data);
396:     }
397: }
398: 
399: class RpcStringHandler extends XmlTagHandler
400: {
401: 
402:     /**
403:      * @return string
404:      */
405:     public function getName()
406:     {
407:         return 'string';
408:     }
409: 
410:     /**
411:      * @param SaxParser $parser
412:      * @param $data
413:      * @return void
414:      */
415:     public function handleCharacterData(SaxParser $parser, &$data)
416:     {
417:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
418:         $parser->setTempValue((string)($data));
419:     }
420: }
421: 
422: class RpcDateTimeHandler extends XmlTagHandler
423: {
424: 
425:     /**
426:      * @return string
427:      */
428:     public function getName()
429:     {
430:         return 'dateTime.iso8601';
431:     }
432: 
433:     /**
434:      * @param SaxParser $parser
435:      * @param $data
436:      * @return void
437:      */
438:     public function handleCharacterData(SaxParser $parser, &$data)
439:     {
440:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
441:         $matches = array();
442:         if (!preg_match("/^([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})$/", $data, $matches)) {
443:             $parser->setTempValue(time());
444:         } else {
445:             $parser->setTempValue(gmmktime($matches[4], $matches[5], $matches[6], $matches[2], $matches[3], $matches[1]));
446:         }
447:     }
448: }
449: 
450: class RpcBase64Handler extends XmlTagHandler
451: {
452: 
453:     /**
454:      * @return string
455:      */
456:     public function getName()
457:     {
458:         return 'base64';
459:     }
460: 
461:     /**
462:      * @param SaxParser $parser
463:      * @param $data
464:      * @return void
465:      */
466:     public function handleCharacterData(SaxParser $parser, &$data)
467:     {
468:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
469:         $parser->setTempValue(base64_decode($data));
470:     }
471: }
472: 
473: class RpcNameHandler extends XmlTagHandler
474: {
475: 
476:     /**
477:      * @return string
478:      */
479:     public function getName()
480:     {
481:         return 'name';
482:     }
483: 
484:     /**
485:      * @param SaxParser $parser
486:      * @param $data
487:      * @return void
488:      */
489:     public function handleCharacterData(SaxParser $parser, &$data)
490:     {
491:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
492:         switch ($parser->getParentTag()) {
493:             case 'member':
494:                 $parser->setTempName($data);
495:                 break;
496:             default:
497:                 break;
498:         }
499:     }
500: }
501: 
502: 
503: class RpcValueHandler extends XmlTagHandler
504: {
505: 
506:     /**
507:      * @return string
508:      */
509:     public function getName()
510:     {
511:         return 'value';
512:     }
513: 
514:     /**
515:      * @param SaxParser $parser
516:      * @param $data
517:      * @return void
518:      */
519:     public function handleCharacterData(SaxParser $parser, &$data)
520:     {
521:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
522:         switch ($parser->getParentTag()) {
523:             case 'member':
524:                 $parser->setTempValue($data);
525:                 break;
526:             case 'data':
527:             case 'array':
528:                 $parser->setTempValue($data);
529:                 break;
530:             default:
531:                 break;
532:         }
533:     }
534: 
535:     /**
536:      * @param SaxParser $parser
537:      * @param $attributes
538:      * @return void
539:      */
540:     public function handleBeginElement(SaxParser $parser, &$attributes)
541:     {
542:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
543:         //$parser->resetTempValue();
544:     }
545: 
546:     /**
547:      * @param SaxParser $parser
548:      * @return void
549:      */
550:     public function handleEndElement(SaxParser $parser)
551:     {
552:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
553:         switch ($parser->getCurrentTag()) {
554:             case 'member':
555:                 $parser->setTempMember($parser->getTempName(), $parser->getTempValue());
556:                 break;
557:             case 'array':
558:             case 'data':
559:                 $parser->setTempArray($parser->getTempValue());
560:                 break;
561:             default:
562:                 $parser->setParam($parser->getTempValue());
563:                 break;
564:         }
565:         $parser->resetTempValue();
566:     }
567: }
568: 
569: class RpcMemberHandler extends XmlTagHandler
570: {
571: 
572:     /**
573:      * @return string
574:      */
575:     public function getName()
576:     {
577:         return 'member';
578:     }
579: 
580:     /**
581:      * @param SaxParser $parser
582:      * @param array $attributes
583:      * @return void
584:      */
585:     public function handleBeginElement(SaxParser $parser, &$attributes)
586:     {
587:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
588:         $parser->setWorkingLevel();
589:         $parser->resetTempMember();
590:     }
591: 
592:     /**
593:      * @param SaxParser $parser
594:      * @return void
595:      */
596:     public function handleEndElement(SaxParser $parser)
597:     {
598:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
599:         $member = $parser->getTempMember();
600:         $parser->releaseWorkingLevel();
601:         $parser->setTempStruct($member);
602:     }
603: }
604: 
605: class RpcArrayHandler extends XmlTagHandler
606: {
607: 
608:     /**
609:      * @return string
610:      */
611:     public function getName()
612:     {
613:         return 'array';
614:     }
615: 
616:     /**
617:     * @param SaxParser $parser
618:     * @param array $attributes
619:     * @return void
620:     */
621:     public function handleBeginElement(SaxParser $parser, &$attributes)
622:     {
623:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
624:         $parser->setWorkingLevel();
625:         $parser->resetTempArray();
626:     }
627: 
628:     /**
629:      * @param SaxParser $parser
630:      * @return void
631:      */
632:     public function handleEndElement(SaxParser $parser)
633:     {
634:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
635:         $parser->setTempValue($parser->getTempArray());
636:         $parser->releaseWorkingLevel();
637:     }
638: }
639: 
640: class RpcStructHandler extends XmlTagHandler
641: {
642: 
643:     /**
644:      * @return string
645:      */
646:     public function getName()
647:     {
648:         return 'struct';
649:     }
650: 
651:     /**
652:      * @param SaxParser $parser
653:      * @param array $attributes
654:      * @return void
655:      */
656:     public function handleBeginElement(SaxParser $parser, &$attributes)
657:     {
658:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
659:         $parser->setWorkingLevel();
660:         $parser->resetTempStruct();
661:     }
662: 
663:     /**
664:      * @param SaxParser $parser
665:      * @return void
666:      */
667:     public function handleEndElement(SaxParser $parser)
668:     {
669:         if (!is_a($parser,'XoopsXmlRpcParser')) return;
670:         $parser->setTempValue($parser->getTempStruct());
671:         $parser->releaseWorkingLevel();
672:     }
673: }
674: