/class.phpwsdlcomplex.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_complexHook','internal','PhpWsdlComplex::InterpretComplex');

PhpWsdl::RegisterHook('CreateObjectHook','internalcomplex','PhpWsdlComplex::CreateComplexTypeObject');



/**

 * This class creates complex types (classes or arrays)

 * 

 * @author Andreas Müller-Saala, wan24.de

 */

class PhpWsdlComplex extends PhpWsdlObject{

	/**

	 * The array type

	 * 

	 * @var string

	 */

	public $Type=null;

	/**

	 * Name of the complex type to inherit from

	 * 

	 * @var string

	 */

	public $Inherit=null;

	/**

	 * A list of elements, if this type is a class

	 * 

	 * @var PhpWsdlElement[]

	 */

	public $Elements;

	/**

	 * Is this type an array?

	 * 

	 * @var boolean

	 */

	public $IsArray;

	/**

	 * Enable creating a PHP constructor that requires all parameters?

	 * 

	 * @var boolean

	 */

	public $EnablePhpConstructor=false;

	/**

	 * Disable definition of arrays with the "Array" postfix in the type name?

	 * 

	 * @var boolean

	 */

	public static $DisableArrayPostfix=false;

	/**

	 * Create a PHP constructor that requires all parameters per default?

	 * 

	 * @var boolean

	 */

	public static $DefaultEnablePhpConstructor=false;

	

	/**

	 * Constructor

	 * 

	 * @param string $name The name

	 * @param PhpWsdlElement[] $el Optional a list of elements

	 * @param array $settings Optional the settings hash array (default: NULL)

	 */

	public function PhpWsdlComplex($name,$el=Array(),$settings=null){

		PhpWsdl::Debug('New complex type '.$name);

		parent::PhpWsdlObject($name,$settings);

		if(!self::$DisableArrayPostfix){

			$this->IsArray=substr($name,strlen($name)-5,5)=='Array';

			if($this->IsArray)

				$this->Type=substr($this->Name,0,strlen($this->Name)-5);

		}

		$this->Elements=$el;

		$this->EnablePhpConstructor=self::$DefaultEnablePhpConstructor;

		if(!is_null($settings)){

			if(isset($settings['isarray']))

				$this->IsArray=$settings['isarray'];

			if(isset($settings['phpconstructor']))

				$this->EnablePhpConstructor=$settings['phpconstructor']=='1'||$settings['phpconstructor']=='true';

			if(isset($settings['type']))

				$this->IsArray=$settings['type'];

			if(isset($settings['inherit']))

				$this->Inherit=$settings['inherit'];

		}

	}

	

	/**

	 * Create WSDL for the type

	 * 

	 * @param PhpWsdl $pw The PhpWsdl object

	 * @return string The WSDL

	 */

	public function CreateType($pw){

		$res=Array();

		$res[]='<s:complexType 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>';

		}

		if(!$this->IsArray){

			PhpWsdl::Debug('Create WSDL definition for type '.$this->Name.' as type');

			if(is_null($this->Inherit)){

				$res[]='<s:sequence>';

				$i=-1;

				$len=sizeof($this->Elements);

				while(++$i<$len)

					$res[]=$this->Elements[$i]->CreateElement($pw);

				$res[]='</s:sequence>';

			}else{

				PhpWsdl::Debug('Inherit from "'.$this->Inherit.'"');

				$res[]='<s:complexContent>';

				$res[]='<s:extension base="tns:'.$this->Inherit.'">';

				$res[]='<s:sequence>';

				$i=-1;

				$len=sizeof($this->Elements);

				while(++$i<$len)

					$res[]=$this->Elements[$i]->CreateElement($pw);

				$res[]='</s:sequence>';

				$res[]='</s:extension>';

				$res[]='</s:complexContent>';

			}

		}else{

			PhpWsdl::Debug('Create WSDL definition for type '.$this->Name.' as array');

			$res[]='<s:complexContent>';

			$res[]='<s:restriction base="soapenc:Array">';

			$res[]='<s:attribute ref="soapenc:arrayType" wsdl:arrayType="'.PhpWsdl::TranslateType($this->Type).'[]" />';

			$res[]='</s:restriction>';

			$res[]='</s:complexContent>';

		}

		$res[]='</s:complexType>';

		return implode('',$res);

	}

	

	/**

	 * Find an element within this type

	 * 

	 * @param string $name The name

	 * @return PhpWsdlElement The element or NULL, if not found

	 */

	public function GetElement($name){

		PhpWsdl::Debug('Find element '.$name);

		$i=-1;

		$len=sizeof($this->Elements);

		while(++$i<$len)

			if($this->Elements[$i]->Name==$name){

				PhpWsdl::Debug('Found element at index '.$i);

				return $this->Elements[$i];

			}

		return null;

	}

	

	/**

	 * Create the HTML documentation for a complex type

	 * 

	 * @param array $data

	 */

	public function CreateTypeHtml($data){

		PhpWsdl::Debug('CreateTypeHtml for '.$data['type']->Name);

		$server=$data['server'];

		$res=&$data['res'];

		$t=&$data['type'];

		$res[]='<h3>'.$t->Name.'</h3>';

		$res[]='<a name="'.$t->Name.'"></a>';

		if(!is_null($t->Inherit))

			$res[]='<p>This type inherits all properties from <a href="#'.$t->Inherit.'"><span class="lightBlue">'.$t->Inherit.'</span></a>.</p>';

		$eLen=sizeof($t->Elements);

		if($t->IsArray){

			// Array type

			$res[]='<p>This is an array type of <span class="pre">';

			$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].='</span>.</p>';

			if(!is_null($t->Docs))

				$res[]='<p>'.nl2br(htmlentities($t->Docs)).'</p>';

		}else if($eLen>0){

			// Complex type with elements

			if(!is_null($t->Docs))

				$res[]='<p>'.nl2br(htmlentities($t->Docs)).'</p>';

			$res[]='<ul class="pre">';

			$j=-1;

			while(++$j<$eLen)

				$t->Elements[$j]->CreateElementHtml(array_merge(

					$data,

					Array(

						'element'		=>	$t->Elements[$j]

					)

				));

			$res[]='</ul>';

		}else{

			// Complex type without elements

			$res[]='<p>This type has no elements.</p>';

		}

		PhpWsdl::CallHook(

			'CreateTypeHtmlHook',

			$data

		);

	}

	

	/**

	 * Create type PHP code

	 * 

	 * @param array $data The event data

	 */

	public function CreateTypePhp($data){

		if($this->IsArray)

			return;

		$server=$data['server'];

		$res=&$data['res'];

		$res[]="/**";

		if(!is_null($this->Docs)){

			$res[]=" * ".implode("\n * ",explode("\n",$this->Docs));

			$res[]=" *";

		}

		$temp=Array();

		$i=-1;

		$eLen=sizeof($this->Elements);

		while(++$i<$eLen){

			$e=$this->Elements[$i];

			$temp[]='$'.$e->Name;

			$res[]=" * @pw_element ".$e->Type." \$".$e->Name.((!is_null($e->Docs))?' '.$e->Docs:'');

		}

		$res[]=" * @pw_complex ".$this->Name;

		$res[]=" */";

		$res[]="class ".$this->Name.((is_null($this->Inherit))?'':' extends '.$this->Inherit)."{";

		if($eLen>0&&$this->EnablePhpConstructor){

			$res[]="\t/**";

			$res[]="\t * Constructor with parameters (all required!)";

			$res[]="\t *";

			$i=-1;

			while(++$i<$eLen){

				$e=$this->Elements[$i];

				$res[]="\t * @param ".$e->Type." ".$temp[$i].((!is_null($e->Docs))?' '.$e->Docs:'');

			}

			if(!is_null($this->Inherit)){

				$it=$server->GetType($this->Inherit);

				if($it->EnablePhpConstructor){

					$i=-1;

					$tLen=sizeof($it->Elements);

					while(++$i<$tLen){

						$e=$it->Elements[$i];

						$tempb[]='$'.$e->Name;

						$res[]=" * @param ".$e->Type." \$".$e->Name.((!is_null($e->Docs))?' '.$e->Docs:'');

					}

				}

			}

			$res[]="\t */";

			$res[]="\tpublic function ".$this->Name."(".implode(',',$temp)."){";

			if(!is_null($this->Inherit)&&$it->EnablePhpConstructor)

				$res[]="\t\tparent::".$this->Inherit."(".implode(',',$tempb).");";

			$i=-1;

			while(++$i<$eLen)

				$res[]="\t\t\$this->".$this->Elements[$i]->Name."=".$temp[$i];

			$res[]="\t}";

		}

		$i=-1;

		while(++$i<$eLen){

			$e=$this->Elements[$i];

			$res[]="\t/**";

			if(!is_null($e->Docs)){

				$res[]="\t * ".implode("\n\t * ",explode("\n",$e->Docs));

				$res[]="\t *";

			}

			$res[]="\t * @var ".$e->Type;

			$res[]="\t */";

			$res[]="\tpublic \$".$this->Elements[$i]->Name.";";

		}

		$res[]="}";

	}

	

	/**

	 * Interpret a complex type

	 * 

	 * @param array $data The parser data

	 * @return boolean Response

	 */

	public static function InterpretComplex($data){

		$info=explode(' ',$data['keyword'][1],3);

		if(sizeof($info)<1)

			return true;

		$server=$data['server'];

		$name=$info[0];

		PhpWsdl::Debug('Interpret complex type "'.$name.'"');

		$type=null;

		$docs=null;

		if(strpos($name,'[]')>-1){

			if(sizeof($info)<2){

				PhpWsdl::Debug('WARNING: Invalid array definition!');

				return true;

			}

			$name=substr($name,0,strlen($name)-2);

			if(!is_null($server->GetType($name))){

				PhpWsdl::Debug('WARNING: Double type detected!');

				return true;

			}

			$type=$info[1];

			if($server->ParseDocs)

				if(sizeof($info)>2)

					$docs=$info[2];

			PhpWsdl::Debug('Array "'.$name.'" type of "'.$type.'" definition');

		}else{

			if(!is_null($server->GetType($name))){

				PhpWsdl::Debug('WARNING: Double type detected!');

				return true;

			}

			if(!self::$DisableArrayPostfix&&substr($name,strlen($name)-5)=='Array'){

				$type=substr($name,0,strlen($name)-5);

				PhpWsdl::Debug('Array "'.$name.'" type of "'.$type.'" definition');

			}else{

				PhpWsdl::Debug('Complex type definition');

			}

			if($server->ParseDocs){

				$temp=sizeof($info);

				if($temp>1)

					$docs=($temp>2)?$info[1].' '.$info[2]:$info[1];

			}

		}

		$data['type']=Array(

			'id'			=>	'complex',

			'name'			=>	$name,

			'type'			=>	$type,

			'docs'			=>	$docs

		);

		return false;

	}

	

	/**

	 * Create complex type object

	 * 

	 * @param array $data The parser data

	 * @return boolean Response

	 */

	public static function CreateComplexTypeObject($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']!='complex')

			return true;

		if(!is_null($data['docs'])){

			$data['settings']['docs']=$data['docs'];

		}else{

			$data['settings']['docs']=$data['type']['docs'];

		}

		PhpWsdl::Debug('Add complex type '.$data['type']['name']);

		$data['settings']['isarray']=!is_null($data['type']['type']);

		$data['obj']=new PhpWsdlComplex($data['type']['name'],$data['elements'],$data['settings']);

		$data['obj']->Type=$data['type']['type'];

		$data['settings']=Array();

		$data['server']->Types[]=$data['obj'];

		return true;

	}

}