| <?php |
| /** |
| * File containing the ezcReflectionArrayType class. |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| * @package Reflection |
| * @version //autogen// |
| * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0 |
| */ |
| |
| /** |
| * Provides type information of the array item type or map types |
| * |
| * @package Reflection |
| * @version //autogen// |
| * @author Stefan Marr <mail@stefan-marr.de> |
| * @author Falko Menge <mail@falko-menge.de> |
| * @todo add support for ArrayAccess stuff from http://www.php.net/~helly/php/ext/spl/ |
| */ |
| class ezcReflectionArrayType extends ezcReflectionPrimitiveType { |
| |
| /**#@+ |
| * @var ezcReflectionType |
| */ |
| // protected $arrayType; |
| // protected $mapKeyType; |
| // protected $mapValueType; |
| protected $keyType; |
| protected $valueType; |
| /**#@-*/ |
| |
| /**#@+ |
| * @var boolean |
| */ |
| protected $isList = false; |
| /**#@-*/ |
| |
| /** |
| * @param string $typeName |
| */ |
| public function __construct($typeName) |
| { |
| parent::__construct($typeName); |
| $this->_parseTypeName(); |
| } |
| |
| /** |
| * Returns true if this array has been documented as a list, i.e., using |
| * the notation of any type name followed by a pair of square brakets. |
| * |
| * Examples of list types include mixed[], stdClass[], sting[][], or |
| * array(mixed=>mixed)[]. |
| * |
| * @return boolean True this array has been documented as a list. |
| */ |
| public function isList () |
| { |
| return $this->isList; |
| } |
| |
| |
| /** |
| * Returns key type of the array |
| * |
| * @return ezcReflectionType |
| */ |
| public function getKeyType() |
| { |
| return $this->keyType; |
| } |
| |
| /** |
| * Returns value type of the array |
| * |
| * @return ezcReflectionType |
| */ |
| public function getValueType() |
| { |
| return $this->valueType; |
| } |
| |
| /** |
| * @return boolean |
| */ |
| public function isArray() |
| { |
| return true; |
| } |
| |
| /** |
| * Returns wether this array is documented as 'array(mixed=>mixed)' or |
| * simply 'array'. |
| * |
| * @return boolean |
| */ |
| public function isMap() |
| { |
| return !$this->isList(); |
| } |
| |
| /** |
| * Internal method for parsing array type names. |
| * |
| * @return void |
| */ |
| protected function _parseTypeName() |
| { |
| //* |
| if ( strlen( $this->typeName ) > 0 ) |
| { |
| // last two chars are [], thus it should be something like string[] |
| //if ( strlen( $this->typeName ) > 2 and substr( $this->typeName, -2 ) == '[]' ) |
| if ( preg_match( ezcReflectionTypeMapper::REGEXP_TYPE_NAME_LIST, $this->typeName, $matches ) ) |
| { |
| $this->isList = true; |
| $this->isMap = false; |
| $this->keyType |
| = ezcReflection::getTypeByName( ezcReflectionTypeMapper::CANONICAL_NAME_INTEGER ); |
| $this->valueType |
| = ezcReflection::getTypeByName( $matches[1] ); |
| } |
| |
| // may be the author just wrote 'array' |
| elseif ( $this->typeName == ezcReflectionTypeMapper::CANONICAL_NAME_ARRAY ) |
| { |
| $this->isList = false; |
| $this->isMap = true; |
| $this->keyType |
| = ezcReflection::getTypeByName( ezcReflectionTypeMapper::CANONICAL_NAME_MIXED ); |
| $this->valueType |
| = ezcReflection::getTypeByName( ezcReflectionTypeMapper::CANONICAL_NAME_MIXED ); |
| } |
| |
| // test for array map types array(int=>float) |
| elseif ( preg_match( ezcReflectionTypeMapper::REGEXP_TYPE_NAME_MAP, $this->typeName, $matches ) ) |
| { |
| $this->isList = false; |
| $this->isMap = true; |
| $this->keyType |
| = ezcReflection::getTypeByName( $matches[1] ); |
| $this->valueType |
| = ezcReflection::getTypeByName( $matches[2] ); |
| } |
| } |
| /*/ |
| $seamsToBeMap = false; |
| $pos = strrpos($this->typeName, '['); |
| //there seams to be an array |
| if ($pos !== false) { |
| //proof there is no array map annotation around |
| $posm = strrpos($this->typeName, ')'); |
| if ($posm !== false) { |
| if ($posm < $pos) { |
| $typeName = substr($this->typeName, 0, $pos); |
| $this->arrayType |
| = ezcReflection::getTypeByName($typeName); |
| } |
| } |
| else { |
| $typeName = substr($this->typeName, 0, $pos); |
| $this->arrayType |
| = ezcReflection::getTypeByName($typeName); |
| } |
| } |
| // TO BE DONE: add support for array(integer => mixed) |
| if (preg_match(self::TYPE_NAME_REGEXP, $this->typeName, $matches)) { |
| $type1 = null; |
| $type2 = null; |
| if (isset($matches[3])) { |
| $type1 = ezcReflection::getTypeByName($matches[3]); |
| } |
| if (isset($matches[5])) { |
| $type2 = ezcReflection::getTypeByName($matches[5]); |
| } |
| |
| if ($type1 == null and $type2 != null) { |
| $this->arrayType = $type2; |
| } |
| elseif ($type1 != null and $type2 == null) { |
| $this->arrayType = $type1; |
| } |
| elseif ($type1 != null and $type2 != null) { |
| $this->mapKeyType = $type1; |
| $this->mapValueType = $type2; |
| } |
| } |
| //*/ |
| } |
| |
| /** |
| * Returns the canonical name for this array, which can be used in type |
| * annotations. |
| * |
| * @return string Canonical name for this array |
| */ |
| public function getTypeName() |
| { |
| if ( $this->isList() ) |
| { |
| return $this->getValueType()->getTypeName().'[]'; |
| } |
| else |
| { |
| return 'array(' . $this->getKeyType()->getTypeName() |
| . '=>' . $this->getValueType()->getTypeName() . ')'; |
| } |
| } |
| |
| /** |
| * Returns XML Schema name of the complexType for the array |
| * |
| * The `this namespace' (tns) prefix is comonly used to refer to the |
| * current XML Schema document. |
| * |
| * @param boolean $usePrefix augments common prefix `tns:' to the name |
| * @return string |
| */ |
| function getXmlName( $usePrefix = true ) |
| { |
| if ( $usePrefix ) { |
| $prefix = 'tns:'; |
| } else { |
| $prefix = ''; |
| } |
| if ( $this->isList() ) |
| { |
| return $prefix . 'ArrayOf' . $this->getValueType()->getXmlName( false ); |
| } |
| else |
| { |
| throw new Exception( 'XML Schema mapping is not supported for map-types' ); |
| } |
| } |
| |
| /** |
| * @return string |
| */ |
| function getNamespace() { |
| return ''; |
| } |
| |
| /** |
| * Returns an <xsd:complexType/> |
| * |
| * @example |
| * <xs:complexType name="ArrayOfLecture"> |
| * <xs:sequence> |
| * <xs:element minOccurs="0" maxOccurs="unbounded" |
| * name="Lecture" nillable="true" type="tns:Lecture" /> |
| * </xs:sequence> |
| * </xs:complexType> |
| * |
| * @param DOMDocument $dom |
| * @return DOMElement |
| */ |
| function getXmlSchema(DOMDocument $dom, $namespaceXMLSchema = 'http://www.w3.org/2001/XMLSchema') { |
| if ( !$this->isList() ) |
| { |
| throw new Exception('XML Schema mapping is not supported for map-types'); |
| } |
| |
| $schema = $dom->createElementNS($namespaceXMLSchema, 'xsd:complexType'); |
| $schema->setAttribute('name', $this->getXmlName(false)); |
| |
| $seq = $dom->createElementNS($namespaceXMLSchema, 'xsd:sequence'); |
| $schema->appendChild($seq); |
| $elm = $dom->createElementNS($namespaceXMLSchema, 'xsd:element'); |
| $seq->appendChild($elm); |
| |
| $elm->setAttribute('minOccurs', '0'); |
| $elm->setAttribute('maxOccurs', 'unbounded'); |
| $elm->setAttribute('nillable', 'true'); |
| |
| $elm->setAttribute( 'name', $this->getValueType()->getXmlName( false ) ); |
| $elm->setAttribute( 'type', $this->getValueType()->getXmlName( true ) ); |
| |
| return $schema; |
| } |
| } |
| |
| ?> |
