class.phpwsdlenum.php

<?php

/*
PhpWsdl - Generate WSDL from PHP
Copyright (C) 2011  Andreas M�ller-Saala, wan24.de

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 3 of the License, or (at your option) any later
version.

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. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with
this program; if not, see <http://www.gnu.org/licenses/>.
*/

if (basename($_SERVER['SCRIPT_FILENAME']) == basename(__FILE__))
    exit;

PhpWsdl::RegisterHook('InterpretKeywordpw_enumHook', 'internal', 'PhpWsdlEnum::InterpretEnum');
PhpWsdl::RegisterHook('CreateObjectHook', 'internalenum', 'PhpWsdlEnum::CreateEnumTypeObject');

/**
 * This class creates enumerations
 *
 * @author Andreas M�ller-Saala, wan24.de
 */
class PhpWsdlEnum extends PhpWsdlObject
{
    /**
     * An XML string encoding mapping for attributes
     *
     * @var array
     */
    public static $XmlAttributeEntities = array(
        '&' => '&amp;',
        '<' => '&lt;',
        '>' => '&gt;',
        '"' => '&quot;'
    );
    /**
     * The enumeration base type
     *
     * @var string
     */
    public $Type;
    /**
     * A list of elements
     *
     * @var array
     */
    public $Elements;

    /**
     * Constructor
     *
     * @param string $name The name
     * @param string $type The type name
     * @param array $el Optional a list of elements
     * @param null $settings Optional the settings hash array (default: NULL)
     * @throws Exception
     */
    public function __construct($name, $type, $el = array(), $settings = null)
    {
        PhpWsdl::Debug('New enumeration type ' . $name . ' of ' . $type);
        if ($type == 'boolean')
            throw(new Exception('Boolean enumeration type is not valid'));
        parent::PhpWsdlObject($name, $settings);
        $this->Type = $type;
        $this->Elements = $el;
    }

    /**
     * Interpret an enumeration
     *
     * @param array $data The parser data
     * @return boolean Response
     */
    public static function InterpretEnum($data)
    {
        $info = explode(' ', $data['keyword'][1], 4);
        if (sizeof($info) < 3)
            return true;
        $server = $data['server'];
        $name = $info[1];
        PhpWsdl::Debug('Interpret enumeration "' . $name . '"');
        $type = $info[0];
        $el = explode(',', $info[2]);
        $docs = null;
        if ($server->ParseDocs)
            if (sizeof($info) > 3)
                $docs = $info[3];
        PhpWsdl::Debug('Enumeration "' . $name . '" type of "' . $type . '" definition');
        $data['type'] = array(
            'id' => 'enum',
            'name' => $name,
            'type' => $type,
            'elements' => $el,
            'docs' => $docs
        );
        return false;
    }

    /**
     * Create enumeration object
     *
     * @param array $data The parser data
     * @return boolean Response
     */
    public static function CreateEnumTypeObject($data)
    {
        if ($data['method'] != '')
            return true;
        if (!is_null($data['obj']))
            return true;
        if (!is_array($data['type']))
            return true;
        if (!isset($data['type']['id']))
            return true;
        if ($data['type']['id'] != 'enum')
            return true;
        if (!isset($data['type']['elements']))
            return true;
        if (!is_array($data['type']['elements']))
            return true;
        if (!is_null($data['docs'])) {
            $data['settings']['docs'] = $data['docs'];
        } else {
            $data['settings']['docs'] = $data['type']['docs'];
        }
        PhpWsdl::Debug('Add enumeration ' . $data['type']['name']);
        $data['obj'] = new PhpWsdlEnum($data['type']['name'], $data['type']['type'], $data['type']['elements'], $data['settings']);
        $data['settings'] = array();
        $data['server']->Types[] = $data['obj'];
        return true;
    }

    /**
     * Create WSDL for the type
     *
     * @param PhpWsdl $pw The PhpWsdl object
     * @return string The WSDL
     */
    public function CreateType($pw)
    {
        PhpWsdl::Debug('Create WSDL definition for enumeration ' . $this->Name . ' as ' . $this->Type);
        $res = array();
        $res[] = '<s:simpleType name="' . $this->Name . '">';
        if ($pw->IncludeDocs && !$pw->Optimize && !is_null($this->Docs)) {
            $res[] = '<s:annotation>';
            $res[] = '<s:documentation><![CDATA[' . $this->Docs . ']]></s:documentation>';
            $res[] = '</s:annotation>';
        }
        $res[] = '<s:restriction base="' . PhpWsdl::TranslateType($this->Type) . '">';
        $i = -1;
        $len = sizeof($this->Elements);
        while (++$i < $len) {
            $temp = explode('=', $this->Elements[$i], 2);
            //TODO Is there really no common way to provide a label for an integer value f.e.?
            $res[] = '<s:enumeration value="' . self::EncodeXmlAttribute($temp[0]) . '" />';
        }
        $res[] = '</s:restriction>';
        $res[] = '</s:simpleType>';
        return implode('', $res);
    }

    /**
     * Encode a string for use as XML attribute
     *
     * @param string $str The string
     * @return string The encoded string
     */
    private static function EncodeXmlAttribute($str)
    {
        $keys = array_keys(self::$XmlAttributeEntities);
        $i = -1;
        $len = sizeof($keys);
        while (++$i < $len)
            $str = str_replace($keys[$i], self::$XmlAttributeEntities[$keys[$i]], $str);
        return $str;
    }

    /**
     * Find an element within this type
     *
     * @param string $value The value to search for
     * @return mixed The element or NULL, if not found
     */
    public function GetElement($value)
    {
        PhpWsdl::Debug('Find element ' . $value);
        $i = -1;
        $len = sizeof($this->Elements);
        while (++$i < $len)
            if ($this->Elements[$i] == $value) {
                PhpWsdl::Debug('Found element at index ' . $i);
                return $this->Elements[$i];
            }
        return null;
    }

    /**
     * Create the HTML documentation for an enumeration
     *
     * @param array $data
     */
    public function CreateTypeHtml($data)
    {
        PhpWsdl::Debug('CreateTypeHtml for enumeration ' . $data['type']->Name);
        $res =& $data['res'];
        $t =& $data['type'];
        $res[] = '<h3>' . $t->Name . '</h3>';
        $res[] = '<a name="' . $t->Name . '"></a>';
        if (!is_null($t->Docs))
            $res[] = '<p>' . nl2br(htmlentities($t->Docs)) . '</p>';
        $res[] = '<p>Possible ';
        $o = sizeof($res) - 1;
        if (in_array($t->Type, PhpWsdl::$BasicTypes)) {
            $res[$o] .= '<span class="blue">' . $t->Type . '</span>';
        } else {
            $res[$o] .= '<a href="#' . $t->Type . '"><span class="lightBlue">' . $t->Type . '</span></a>';
        }
        $res[$o] .= ' values:</p>';
        $res[] = '<ul class="pre">';
        $j = -1;
        $eLen = sizeof($t->Elements);
        while (++$j < $eLen)
            $res[] = '<li>' . nl2br(htmlentities($this->Elements[$j])) . '</li>';
        $res[] = '</ul>';
        PhpWsdl::CallHook(
            'CreateTypeHtmlHook',
            $data
        );
    }

    /**
     * Create enumeration PHP code
     *
     * @param array $data The event data
     */
    public function CreateTypePhp($data)
    {
        $server = $data['server'];
        $res =& $data['res'];
        $res[] = "/**";
        if (!is_null($this->Docs)) {
            $res[] = " * " . implode("\n * ", explode("\n", $this->Docs));
            $res[] = " *";
        }
        $res[] = " * @pw_enum " . $this->Type . " " . $this->Name . " " . implode(',', $this->Elements);
        $res[] = " */";
        $res[] = "abstract class " . $this->Name . "{";
        $i = -1;
        $eLen = sizeof($this->Elements);
        while (++$i < $eLen) {
            $temp = explode('=', $this->Elements[$i], 2);
            if (sizeof($temp) == 1) $temp[] = $temp[0];// Use the key as string value, if no value was given
            $res[] = "\t/**";
            $res[] = "\t * @var " . $this->Type;
            $res[] = "\t */";
            $res[] = "\tconst \$" . $temp[0] . "=\"" . addslashes($temp[1]) . "\";";
        }
        $res[] = "}";
    }
}