xmlrpcparser.php

Go to the documentation of this file.

<?php
/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/

class XoopsXmlRpcParser extends SaxParser
{

    protected $_param;

    protected $_methodName;

    protected $_tempName;

    protected $_tempValue;

    protected $_tempMember;

    protected $_tempStruct;

    protected $_tempArray;

    protected $_workingLevel = array();


    public function __construct(&$input)
    {
        parent::__construct($input);
        $this->addTagHandler(new RpcMethodNameHandler());
        $this->addTagHandler(new RpcIntHandler());
        $this->addTagHandler(new RpcDoubleHandler());
        $this->addTagHandler(new RpcBooleanHandler());
        $this->addTagHandler(new RpcStringHandler());
        $this->addTagHandler(new RpcDateTimeHandler());
        $this->addTagHandler(new RpcBase64Handler());
        $this->addTagHandler(new RpcNameHandler());
        $this->addTagHandler(new RpcValueHandler());
        $this->addTagHandler(new RpcMemberHandler());
        $this->addTagHandler(new RpcStructHandler());
        $this->addTagHandler(new RpcArrayHandler());
    }

    public function setTempName($name)
    {
        $this->_tempName[$this->getWorkingLevel()] = $name;
    }

    public function getTempName()
    {
        return $this->_tempName[$this->getWorkingLevel()];
    }

    public function setTempValue($value)
    {
        if (is_array($value)) {
            settype($this->_tempValue, 'array');
            foreach ($value as $k => $v) {
                $this->_tempValue[$k] = $v;
            }
        } elseif (is_string($value)) {
            if (isset($this->_tempValue)) {
                if (is_string($this->_tempValue)) {
                    $this->_tempValue .= $value;
                }
            } else {
                $this->_tempValue = $value;
            }
        } else {
            $this->_tempValue = $value;
        }
    }

    public function getTempValue()
    {
        return $this->_tempValue;
    }

    public function resetTempValue()
    {
        $this->_tempValue = null;
    }

    public function setTempMember($name, $value)
    {
        $this->_tempMember[$this->getWorkingLevel()][$name] = $value;
    }

    public function getTempMember()
    {
        return $this->_tempMember[$this->getWorkingLevel()];
    }

    public function resetTempMember()
    {
        $this->_tempMember[$this->getWorkingLevel()] = array();
    }

    public function setWorkingLevel()
    {
        array_push($this->_workingLevel, $this->getCurrentLevel());
    }

    public function getWorkingLevel()
    {
        return (count($this->_workingLevel) > 0)
            ? $this->_workingLevel[count($this->_workingLevel) - 1]
            : null;
    }

    public function releaseWorkingLevel()
    {
        array_pop($this->_workingLevel);
    }

    public function setTempStruct(array $member)
    {
        $key = key($member);
        $this->_tempStruct[$this->getWorkingLevel()][$key] = $member[$key];
    }

    public function getTempStruct()
    {
        return $this->_tempStruct[$this->getWorkingLevel()];
    }

    public function resetTempStruct()
    {
        $this->_tempStruct[$this->getWorkingLevel()] = array();
    }

    public function setTempArray($value)
    {
        $this->_tempArray[$this->getWorkingLevel()][] = $value;
    }

    public function getTempArray()
    {
        return $this->_tempArray[$this->getWorkingLevel()];
    }

    public function resetTempArray()
    {
        $this->_tempArray[$this->getWorkingLevel()] = array();
    }

    public function setMethodName($methodName)
    {
        $this->_methodName = $methodName;
    }

    public function getMethodName()
    {
        return $this->_methodName;
    }

    public function setParam($value)
    {
        $this->_param[] = $value;
    }

    public function getParam()
    {
        return $this->_param;
    }
}


class RpcMethodNameHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'methodName';
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setMethodName($data);
    }
}

class RpcIntHandler extends XmlTagHandler
{

    public function getName()
    {
        return array('int', 'i4');
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setTempValue(intval($data));
    }
}

class RpcDoubleHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'double';
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $data = (float)$data;
        $parser->setTempValue($data);
    }
}

class RpcBooleanHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'boolean';
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $data = (boolean)$data;
        $parser->setTempValue($data);
    }
}

class RpcStringHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'string';
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setTempValue(strval($data));
    }
}

class RpcDateTimeHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'dateTime.iso8601';
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $matches = array();
        if (!preg_match("/^([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})$/", $data, $matches)) {
            $parser->setTempValue(time());
        } else {
            $parser->setTempValue(gmmktime($matches[4], $matches[5], $matches[6], $matches[2], $matches[3], $matches[1]));
        }
    }
}

class RpcBase64Handler extends XmlTagHandler
{

    public function getName()
    {
        return 'base64';
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setTempValue(base64_decode($data));
    }
}

class RpcNameHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'name';
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        switch ($parser->getParentTag()) {
            case 'member':
                $parser->setTempName($data);
                break;
            default:
                break;
        }
    }
}


class RpcValueHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'value';
    }

    public function handleCharacterData(SaxParser &$parser, &$data)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        switch ($parser->getParentTag()) {
            case 'member':
                $parser->setTempValue($data);
                break;
            case 'data':
            case 'array':
                $parser->setTempValue($data);
                break;
            default:
                break;
        }
    }

    public function handleBeginElement(SaxParser &$parser, &$attributes)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        //$parser->resetTempValue();
    }

    public function handleEndElement(SaxParser &$parser)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        switch ($parser->getCurrentTag()) {
            case 'member':
                $parser->setTempMember($parser->getTempName(), $parser->getTempValue());
                break;
            case 'array':
            case 'data':
                $parser->setTempArray($parser->getTempValue());
                break;
            default:
                $parser->setParam($parser->getTempValue());
                break;
        }
        $parser->resetTempValue();
    }
}

class RpcMemberHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'member';
    }

    public function handleBeginElement(SaxParser &$parser, &$attributes)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setWorkingLevel();
        $parser->resetTempMember();
    }

    public function handleEndElement(SaxParser &$parser)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $member = $parser->getTempMember();
        $parser->releaseWorkingLevel();
        $parser->setTempStruct($member);
    }
}

class RpcArrayHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'array';
    }

    public function handleBeginElement(SaxParser &$parser, &$attributes)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setWorkingLevel();
        $parser->resetTempArray();
    }

    public function handleEndElement(SaxParser &$parser)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setTempValue($parser->getTempArray());
        $parser->releaseWorkingLevel();
    }
}

class RpcStructHandler extends XmlTagHandler
{

    public function getName()
    {
        return 'struct';
    }

    public function handleBeginElement(SaxParser &$parser, &$attributes)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setWorkingLevel();
        $parser->resetTempStruct();
    }

    public function handleEndElement(SaxParser &$parser)
    {
        if (!is_a($parser,'XoopsXmlRpcParser')) return;
        $parser->setTempValue($parser->getTempStruct());
        $parser->releaseWorkingLevel();
    }
}