<h2>Editing File: /usr/local/cpanel/base/3rdparty/roundcube/vendor/sabre/vobject/lib/Parser/XML.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php

namespace Sabre\VObject\Parser;

use Sabre\VObject\Component;
use Sabre\VObject\Component\VCalendar;
use Sabre\VObject\Component\VCard;
use Sabre\VObject\EofException;
use Sabre\VObject\ParseException;
use Sabre\Xml as SabreXml;

/**
 * XML Parser.
 *
 * This parser parses both the xCal and xCard formats.
 *
 * @copyright Copyright (C) fruux GmbH (https://fruux.com/)
 * @author Ivan Enderlin
 * @license http://sabre.io/license/ Modified BSD License
 */
class XML extends Parser
{
    const XCAL_NAMESPACE = 'urn:ietf:params:xml:ns:icalendar-2.0';
    const XCARD_NAMESPACE = 'urn:ietf:params:xml:ns:vcard-4.0';

    /**
     * The input data.
     *
     * @var array
     */
    protected $input;

    /**
     * A pointer/reference to the input.
     *
     * @var array
     */
    private $pointer;

    /**
     * Document, root component.
     *
     * @var \Sabre\VObject\Document
     */
    protected $root;

    /**
     * Creates the parser.
     *
     * Optionally, it's possible to parse the input stream here.
     *
     * @param mixed $input
     * @param int   $options any parser options (OPTION constants)
     */
    public function __construct($input = null, $options = 0)
    {
        if (0 === $options) {
            $options = parent::OPTION_FORGIVING;
        }

        parent::__construct($input, $options);
    }

    /**
     * Parse xCal or xCard.
     *
     * @param resource|string $input
     * @param int             $options
     *
     * @throws \Exception
     *
     * @return \Sabre\VObject\Document
     */
    public function parse($input = null, $options = 0)
    {
        if (!is_null($input)) {
            $this-&gt;setInput($input);
        }

        if (0 !== $options) {
            $this-&gt;options = $options;
        }

        if (is_null($this-&gt;input)) {
            throw new EofException('End of input stream, or no input supplied');
        }

        switch ($this-&gt;input['name']) {
            case '{'.self::XCAL_NAMESPACE.'}icalendar':
                $this-&gt;root = new VCalendar([], false);
                $this-&gt;pointer = &amp;$this-&gt;input['value'][0];
                $this-&gt;parseVCalendarComponents($this-&gt;root);
                break;

            case '{'.self::XCARD_NAMESPACE.'}vcards':
                foreach ($this-&gt;input['value'] as &amp;$vCard) {
                    $this-&gt;root = new VCard(['version' =&gt; '4.0'], false);
                    $this-&gt;pointer = &amp;$vCard;
                    $this-&gt;parseVCardComponents($this-&gt;root);

                    // We just parse the first &lt;vcard /&gt; element.
                    break;
                }
                break;

            default:
                throw new ParseException('Unsupported XML standard');
        }

        return $this-&gt;root;
    }

    /**
     * Parse a xCalendar component.
     */
    protected function parseVCalendarComponents(Component $parentComponent)
    {
        foreach ($this-&gt;pointer['value'] ?: [] as $children) {
            switch (static::getTagName($children['name'])) {
                case 'properties':
                    $this-&gt;pointer = &amp;$children['value'];
                    $this-&gt;parseProperties($parentComponent);
                    break;

                case 'components':
                    $this-&gt;pointer = &amp;$children;
                    $this-&gt;parseComponent($parentComponent);
                    break;
            }
        }
    }

    /**
     * Parse a xCard component.
     */
    protected function parseVCardComponents(Component $parentComponent)
    {
        $this-&gt;pointer = &amp;$this-&gt;pointer['value'];
        $this-&gt;parseProperties($parentComponent);
    }

    /**
     * Parse xCalendar and xCard properties.
     *
     * @param string $propertyNamePrefix
     */
    protected function parseProperties(Component $parentComponent, $propertyNamePrefix = '')
    {
        foreach ($this-&gt;pointer ?: [] as $xmlProperty) {
            list($namespace, $tagName) = SabreXml\Service::parseClarkNotation($xmlProperty['name']);

            $propertyName = $tagName;
            $propertyValue = [];
            $propertyParameters = [];
            $propertyType = 'text';

            // A property which is not part of the standard.
            if (self::XCAL_NAMESPACE !== $namespace
                &amp;&amp; self::XCARD_NAMESPACE !== $namespace) {
                $propertyName = 'xml';
                $value = '&lt;'.$tagName.' xmlns=&quot;'.$namespace.'&quot;';

                foreach ($xmlProperty['attributes'] as $attributeName =&gt; $attributeValue) {
                    $value .= ' '.$attributeName.'=&quot;'.str_replace('&quot;', '\&quot;', $attributeValue).'&quot;';
                }

                $value .= '&gt;'.$xmlProperty['value'].'&lt;/'.$tagName.'&gt;';

                $propertyValue = [$value];

                $this-&gt;createProperty(
                    $parentComponent,
                    $propertyName,
                    $propertyParameters,
                    $propertyType,
                    $propertyValue
                );

                continue;
            }

            // xCard group.
            if ('group' === $propertyName) {
                if (!isset($xmlProperty['attributes']['name'])) {
                    continue;
                }

                $this-&gt;pointer = &amp;$xmlProperty['value'];
                $this-&gt;parseProperties(
                    $parentComponent,
                    strtoupper($xmlProperty['attributes']['name']).'.'
                );

                continue;
            }

            // Collect parameters.
            foreach ($xmlProperty['value'] as $i =&gt; $xmlPropertyChild) {
                if (!is_array($xmlPropertyChild)
                    || 'parameters' !== static::getTagName($xmlPropertyChild['name'])) {
                    continue;
                }

                $xmlParameters = $xmlPropertyChild['value'];

                foreach ($xmlParameters as $xmlParameter) {
                    $propertyParameterValues = [];

                    foreach ($xmlParameter['value'] as $xmlParameterValues) {
                        $propertyParameterValues[] = $xmlParameterValues['value'];
                    }

                    $propertyParameters[static::getTagName($xmlParameter['name'])]
                        = implode(',', $propertyParameterValues);
                }

                array_splice($xmlProperty['value'], $i, 1);
            }

            $propertyNameExtended = ($this-&gt;root instanceof VCalendar
                                      ? 'xcal'
                                      : 'xcard').':'.$propertyName;

            switch ($propertyNameExtended) {
                case 'xcal:geo':
                    $propertyType = 'float';
                    $propertyValue['latitude'] = 0;
                    $propertyValue['longitude'] = 0;

                    foreach ($xmlProperty['value'] as $xmlRequestChild) {
                        $propertyValue[static::getTagName($xmlRequestChild['name'])]
                            = $xmlRequestChild['value'];
                    }
                    break;

                case 'xcal:request-status':
                    $propertyType = 'text';

                    foreach ($xmlProperty['value'] as $xmlRequestChild) {
                        $propertyValue[static::getTagName($xmlRequestChild['name'])]
                            = $xmlRequestChild['value'];
                    }
                    break;

                case 'xcal:freebusy':
                    $propertyType = 'freebusy';
                    // We don't break because we only want to set
                    // another property type.

                    // no break
                case 'xcal:categories':
                case 'xcal:resources':
                case 'xcal:exdate':
                    foreach ($xmlProperty['value'] as $specialChild) {
                        $propertyValue[static::getTagName($specialChild['name'])]
                            = $specialChild['value'];
                    }
                    break;

                case 'xcal:rdate':
                    $propertyType = 'date-time';

                    foreach ($xmlProperty['value'] as $specialChild) {
                        $tagName = static::getTagName($specialChild['name']);

                        if ('period' === $tagName) {
                            $propertyParameters['value'] = 'PERIOD';
                            $propertyValue[] = implode('/', $specialChild['value']);
                        } else {
                            $propertyValue[] = $specialChild['value'];
                        }
                    }
                    break;

                default:
                    $propertyType = static::getTagName($xmlProperty['value'][0]['name']);

                    foreach ($xmlProperty['value'] as $value) {
                        $propertyValue[] = $value['value'];
                    }

                    if ('date' === $propertyType) {
                        $propertyParameters['value'] = 'DATE';
                    }
                    break;
            }

            $this-&gt;createProperty(
                $parentComponent,
                $propertyNamePrefix.$propertyName,
                $propertyParameters,
                $propertyType,
                $propertyValue
            );
        }
    }

    /**
     * Parse a component.
     */
    protected function parseComponent(Component $parentComponent)
    {
        $components = $this-&gt;pointer['value'] ?: [];

        foreach ($components as $component) {
            $componentName = static::getTagName($component['name']);
            $currentComponent = $this-&gt;root-&gt;createComponent(
                $componentName,
                null,
                false
            );

            $this-&gt;pointer = &amp;$component;
            $this-&gt;parseVCalendarComponents($currentComponent);

            $parentComponent-&gt;add($currentComponent);
        }
    }

    /**
     * Create a property.
     *
     * @param string $name
     * @param array  $parameters
     * @param string $type
     * @param mixed  $value
     */
    protected function createProperty(Component $parentComponent, $name, $parameters, $type, $value)
    {
        $property = $this-&gt;root-&gt;createProperty(
            $name,
            null,
            $parameters,
            $type
        );
        $parentComponent-&gt;add($property);
        $property-&gt;setXmlValue($value);
    }

    /**
     * Sets the input data.
     *
     * @param resource|string $input
     */
    public function setInput($input)
    {
        if (is_resource($input)) {
            $input = stream_get_contents($input);
        }

        if (is_string($input)) {
            $reader = new SabreXml\Reader();
            $reader-&gt;elementMap['{'.self::XCAL_NAMESPACE.'}period']
                = XML\Element\KeyValue::class;
            $reader-&gt;elementMap['{'.self::XCAL_NAMESPACE.'}recur']
                = XML\Element\KeyValue::class;
            $reader-&gt;xml($input);
            $input = $reader-&gt;parse();
        }

        $this-&gt;input = $input;
    }

    /**
     * Get tag name from a Clark notation.
     *
     * @param string $clarkedTagName
     *
     * @return string
     */
    protected static function getTagName($clarkedTagName)
    {
        list(, $tagName) = SabreXml\Service::parseClarkNotation($clarkedTagName);

        return $tagName;
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fbase%2F3rdparty%2Froundcube%2Fvendor%2Fsabre%2Fvobject%2Flib%2FParser'>Back to Directory</a>